`
Luob.
  • 浏览: 1588704 次
  • 来自: 上海
社区版块
存档分类
最新评论

spring 第6天SpEL,P命名空间,Util Schema

阅读更多
使用p名称空间配置属性
使用p命名空间的功能 和 <property>
<bean id="p_chinese" class="cn.sh.springmvc_java.Chinese" p:name="admin" p:axe-ref="stoneAxe"/>
   	
   <bean id="u_chinese" class="cn.sh.springmvc.model.Chinese"
   	p:age-ref="chin.age" p:axe-ref="stoneAxe"
   	p:schools-ref="chin.schools"
   	p:axes-ref="chin.axes"
   	p:scores-ref="chin.scores"/>
  <!--如果某个bean的属性名以"-ref"结尾,这样p命名空间会出现冲突--->


使用util Schema
 
   <!-- 将指定类的静态Field暴露出来 -->
   <util:constant id="chin.age" static-field="java.sql.Connection.TRANSACTION_SERIALIZABLE"/>
   
   <!-- 将指定bean的属性 暴露出来 -->
   <util:property-path id="test" path="u_chinese.age"/>
   
   <!-- 加载指定资源文件 -->
   <util:properties id="confTest" location="classpath:message_zh_CN.properties"/>
   
   <!-- 定义一个list -->
   <util:list id="chin.schools" list-class="java.util.LinkedList">
   		<value>小学</value>
   		<value>中学</value>
   		<value>大学</value>
   </util:list>
   
   <!-- 定义一个set对象 -->
   <util:set id="chin.axes" set-class="java.util.HashSet">
   		<value>字符串斧子</value>
   		<bean class="cn.sh.springmvc.model.SteelAxe"/>
   		<ref local="stoneAxe"/>
   </util:set>
   
   <!-- 定一个 map对象 -->
   <util:map id="chin.scores" map-class="java.util.TreeMap" key-type="java.lang.String" value-type="java.lang.Double">
   		<entry key="数学" value="89"/>
   		<entry key="英语" value="89"/>
   		<entry key="语文" value="89"/>
   </util:map>

spring表达式  简称 SpEL
先把 表达式在bean中的使用给出来
<bean id="spel_chinese" class="cn.sh.springmvc.model.Chinese"
   	p:name="#{T(java.lang.Math).random()}"
   	p:age="#{new java.util.Random().nextInt(100)}"
   	p:axe="#{new cn.sh.springmvc.model.SteelAxe('made in china')}">
   	<property name="books">
   		<list> 
   			<value>#{confTest.hello}</value>
   			<value>#{confTest.now}</value>
   		</list>
   	</property>
   	</bean>




//测试 SpEL 表达式语言
	@Test
	public void test2() {
		ExpressionParser parser=new SpelExpressionParser();
		Expression exp=parser.parseExpression("'Hello World'");
		System.out.println("Hello World的结果"+exp.getValue());
		
		exp=parser.parseExpression("'Hello World'.concat('!')");
		System.out.println("concat后的结果"+exp.getValue());
		
		exp=parser.parseExpression("'Hello World'.bytes");
		System.out.println("调用getBytes方法后的结果"+exp.getValue());
		
		exp=parser.parseExpression("'Hello World'.bytes.length");
		System.out.println("方法返回值后的属性的结果"+exp.getValue());
		
		exp=parser.parseExpression("new String('Hello World').toUpperCase()");
		System.out.println("upperCase后的结果:"+exp.getValue(String.class));
		
		
		exp=parser.parseExpression("age");
		cn.sh.springmvc.model.Chinese c=act.getBean("u_chinese",cn.sh.springmvc.model.Chinese.class);
		System.out.println("以Chinese为root,age的表达式的值是:"+exp.getValue(c, Integer.class));
		
		
		exp=parser.parseExpression("age==15");
		StandardEvaluationContext ctx=new StandardEvaluationContext();
		ctx.setRootObject(c);
		System.out.println(exp.getValue(ctx, Boolean.class));
		
		List<Boolean> list=new ArrayList<Boolean>();
		list.add(true);
		EvaluationContext ctx2=new StandardEvaluationContext();
		ctx2.setVariable("list",list);
		
		parser.parseExpression("#list[0]").setValue(ctx2, "false");
		System.out.println("List集合中的第一个元素:"+list.get(0));
		
		cn.sh.springmvc.model.Chinese c1=act.getBean("spel_chinese",cn.sh.springmvc.model.Chinese.class);
		c1.test();
		System.out.println(c1.getAxe().chop());
		
	
	}
	@Test
	public void test3() {
		//直接变量表达式
		ExpressionParser parser=new SpelExpressionParser();
		String helloword=parser.parseExpression("'Hello World'").getValue(String.class);
		double num=parser.parseExpression("0.23").getValue(Double.class);
		
		//表达式中创建数组
		Expression exp=parser.parseExpression("new String[]{'java','struts','spring'}");
		System.out.println(exp.getValue());
		
		exp=parser.parseExpression("new int[2][4]");
		System.out.println(exp.getValue());
		
		//创建list
		exp=parser.parseExpression("{'java','struts','spring'}");
		System.out.println(exp.getValue());
		
		//创建 二维 list
		exp=parser.parseExpression("{{'疯狂java讲义',''},{'左转','战国策'}}");
		System.out.println(exp.getValue());
		
		
	}
	
	@Test
	public void test4() {
		//访问 list,Map
		List<String> list=new ArrayList<String>();
		list.add("Java");
		list.add("Spring");
		Map<String,Double> map=new HashMap<String,Double>();
		map.put("Java", 80.0);
		map.put("Spring",89.0);
		ExpressionParser parser=new SpelExpressionParser();
		EvaluationContext ctx=new StandardEvaluationContext();
		ctx.setVariable("list", list);
		ctx.setVariable("map", map);
		System.out.println(parser.parseExpression("#list[0]").getValue(ctx));
		System.out.println(parser.parseExpression("#map['java']").getValue(ctx));
	}

	@Test
	public void test5() {
		ExpressionParser parser=new SpelExpressionParser();
		EvaluationContext ctx=new StandardEvaluationContext();
		System.out.println(parser.parseExpression("'helloworld'.substring(2,5)").getValue());
		
		List<String> list=new ArrayList<String>();
		list.add("Java");
		list.add("Spring");
		list.add("javascript");
		list.add("ios");
		list.add("hibernate");
		list.add("android");
		
		ctx.setVariable("myList", list);
		System.out.println(parser.parseExpression("#myList.subList(1,3)").getValue(ctx));
	}
	
	//运算
	@Test
	public void test6() {
		List<String> list=new ArrayList<String>();
		list.add("Java");
		list.add("Spring");
		list.add("javascript");
		list.add("ios");
		list.add("hibernate");
		list.add("android");
		
		
		ExpressionParser parser=new SpelExpressionParser();
		EvaluationContext ctx=new StandardEvaluationContext();
		ctx.setVariable("myList", list);
		
		parser.parseExpression("#myList[0]='疯狂java讲义'").getValue(ctx);
		System.out.println(list.get(0));
		
		System.out.println(parser.parseExpression("#myList.size() > 3 ? '长度大于3':'长度小于3'").getValue());
		
	}
	//类型运算符 T() 如果类型 在 java.lang包下,T()可以省略 其他包不行 
	@Test
	public void test7() {
		ExpressionParser parser=new SpelExpressionParser();
		System.out.println(parser.parseExpression("T(java.lang.Math).random()").getValue());
		System.out.println(parser.parseExpression("T(System).getProperty('os.name')").getValue());
	}
	
	//使用 new 创建对象 
	@Test
	public void test8() {
		ExpressionParser parser=new SpelExpressionParser();
		
		System.out.println(parser.parseExpression("new String('Helloworld').substring(2,4)").getValue());

		System.out.println(parser.parseExpression("new javax.swing.JFrame('测试').setVisible('true')").getValue());
		
		//三目运算的使用
		//下面两个 相等 
		System.out.println(parser.parseExpression("1 !=null ? 1:2").getValue());
		System.out.println(parser.parseExpression("1?:2").getValue());
		
	}
	
	//安全导航 ?
	@Test
	public void test9() {
		ExpressionParser parser=new SpelExpressionParser();
		
		//这里没有采用 安全导航  会出现 NullPointerException
		System.out.println(parser.parseExpression("#foo.bar").getValue());
		
		//这里采用了,不会出现 NullPointerException
		System.out.println(parser.parseExpression("#foo?.bar").getValue());
	}
	
	//集合中元素 选择
	@Test
	public void test10() {
		List<String> list=new ArrayList<String>();
		list.add("Java");
		list.add("Spring");
		list.add("javascript");
		list.add("ios");
		list.add("hibernate");
		list.add("android");
		
		
		ExpressionParser parser=new SpelExpressionParser();
		EvaluationContext ctx=new StandardEvaluationContext();
		ctx.setVariable("myList", list);
		
		//集合中元素的值的长度大于 7 就寻找出来
		System.out.println(parser.parseExpression("#myList.?[length()>7]")
				.getValue(ctx));
		
		
		Map<String,Double> map=new HashMap<String,Double>();
		map.put("Java", 89.9);
		map.put("hibernate", 60.9);
		map.put("javascript", 79.9);
		map.put("Spring", 50.9);
		ctx.setVariable("myMap", map);

		//map中元素的值 大于  80才被选择出来
		System.out.println(parser.parseExpression("#myMap.?[value>80]").getValue(ctx));
		
		
	}
	
	//集合投影  便利集合中的元素,然后进行指定的操作
	@Test
	public void test11() {
		List<String> list=new ArrayList<String>();
		list.add("Java");
		list.add("Spring");
		list.add("javascript");
		list.add("ios");
		list.add("hibernate");
		list.add("android");
		
		
		ExpressionParser parser=new SpelExpressionParser();
		EvaluationContext ctx=new StandardEvaluationContext();
		ctx.setVariable("myList", list);
		
		//得到的是 原集合中 元素的长度
		System.out.println(parser.parseExpression("#myList.![length()]").getValue(ctx));
		
		List<Chinese> list1=new ArrayList<Chinese>();
		list1.add(new Chinese("java"));
		list1.add(new Chinese("Spring"));
		list1.add(new Chinese("javascript"));
		list1.add(new Chinese("ios"));
		list1.add(new Chinese("hibernate"));
		list1.add(new Chinese("android"));
		
		ctx.setVariable("myList1", list1);
		
		//获取的是原集合中元素的name属性
		System.out.println(parser.parseExpression("#myList1.![name]").getValue(ctx));
	}
	
	
	//表达式模版 
	@Test
	public void test12() {
		ExpressionParser parser=new SpelExpressionParser();
		List<Chinese> list1=new ArrayList<Chinese>();
		list1.add(new Chinese("java"));
		list1.add(new Chinese("Spring"));
		Expression exp=parser.parseExpression("我的名字是#{name}",new TemplateParserContext());
		System.out.println(exp.getValue(list1.get(0)));
	}
分享到:
评论

相关推荐

    Spring_SpEl表达式使用用例

    **Spring SpEL表达式使用详解** Spring Expression Language (SpEL)是Spring框架中的一种强大而灵活的表达式语言,主要用于在运行时查询和操作对象图。它提供了在配置元数据中进行表达式评估的能力,使得我们可以...

    spring spEL 表达式详解

    **Spring SpEL(Spring Expression Language)表达式详解** Spring Expression Language,简称SpEL,是Spring框架中的一个强大表达式语言,用于在运行时查询和操作对象图。它提供了丰富的表达式语法,支持属性访问...

    SpringSecurity笔记2-SpringSecurity命名空间

    在本笔记中,我们将深入探讨Spring Security的命名空间,这是配置该框架的关键部分。通过理解这些命名空间,开发者可以更有效地控制应用程序的安全策略。 首先,Spring Security的核心配置是通过XML命名空间完成的...

    SpringCloud Function SpEL注入漏洞分析(CVE-2022-22963).doc

    SpringCloud Function SpEL 注入漏洞分析(CVE-2022-22963) SpringCloud Function 是 Spring 提供的一套分布式函数式编程组件,旨在帮助开发者专注于业务逻辑实现,而不需要关心服务器环境运维等问题。然而,在 ...

    spring4.2.0的schema约束

    4. **Namespace和Element**:Spring的schema通常包含多个命名空间(namespace),每个命名空间代表一类功能,如`&lt;beans&gt;`、`&lt;context&gt;`、`&lt;aop&gt;`等。每个命名空间下有多个元素(element),如`&lt;bean&gt;`、`&lt;property&gt;`...

    CVE-2022-22947 SpringCloud GateWay SpEL RCE.doc

    CVE-2022-22947 SpringCloud GateWay SpEL RCE CVE-2022-22947是一种影响SpringCloud GateWay的远程代码执行漏洞,通过SpEL(Spring Expression Language)实现RCE(Remote Code Execution)。下面是关于该漏洞的...

    Spring cloud function SpEL RCE批量检测脚本,反弹shell脚本

    Spring Cloud Function 是基于Spring Boot 的函数计算框架,它抽象出所有传输细节和基础架构,允许开发人员保留所有熟悉的工具和流程,并专注于业务逻辑。 批量检测脚本:python Spel_RCE_POC.py url.txt 反弹...

    基于SpringBoot、Spring表达式语言 (SpEL)、annotation的操作日志框架+源代码+文档说明

    基于SpringBoot、Spring表达式语言 (SpEL)、annotation的操作日志 ### 简介 * 使用annotation来标注方法,标记操作内容 * 使用SpEL来动态生成操作日志内容,使操作日志记录更加详细(记录操作内容ID等关键信息) * ...

    Spring表达式语言SpEL用法详解

    &lt;bean id="car" class="com.gong.spring.beans.spel.Car" p:name="baoma" p:tyrePerimeter="#{T(java.lang.Math).PI*80}"&gt; ``` 在上面的例子中,我们使用SpEL来计算tyrePerimeter的值,使用了Java的Math类中的PI常量...

    spring-boot-annotation-spel.zip

    Spring Boot自定义注解配合SPEL(Spring Expression Language)表达式可以让我们实现更为灵活的逻辑控制。本压缩包“spring-boot-annotation-spel.zip”显然是关于如何在自定义注解中运用SPEL表达式的实例教程。 ...

    Spring组件开发模式支持SPEL表达式

    Spring组件开发模式支持SPEL表达式 Spring框架作为Java企业级应用程序的主流框架,提供了强大的组件开发模式,支持SPEL(Spring Expression Language)表达式,使得开发者能够更加灵活地使用表达式来实现业务逻辑。...

    opt-log:基于SpringBoot、Spring表达式语言 (SpEL)、annotation的操作日志框架

    opt-log基于SpringBoot、Spring表达式语言 (SpEL)、annotation的操作日志简介使用annotation来标注方法,标记操作内容使用SpEL来动态生成操作日志内容,使操作日志记录更加详细(记录操作内容ID等关键信息)同一个...

    Spring表达式语言中文参考手册.docx

    ### Spring 表达式语言 (SpEL) 中文参考手册概览 #### 一、Spring SpEL 概念与用途 Spring SpEL(Spring Expression Language)是一种强大的表达式语言,用于处理运行时查询和操作对象图。SpEL 的设计目标是提供一...

    最新版spring-framework-5.0.1.RELEASE-schema.zip约束

    6. **lang** - 这可能包含一些辅助语言工具,如反射、类型转换和表达式语言(SpEL),SpEL是Spring的强大的表达式语言,用于在运行时查询和操作对象。 7. **aop** - 面向切面编程(AOP)模块,用于定义横切关注点,...

    day38 13-Spring的Bean的属性的注入:SpEL注入

    本篇将详细探讨Spring中的SpEL(Spring Expression Language)注入,这是一种强大的表达式语言,用于在运行时查询和操作对象图。 首先,SpEL提供了一种简洁的方式来访问和操作Bean的属性,它允许我们在配置中使用...

    Spring第一天.pdf

    - **SpEL (Spring Expression Language)**:表达式语言,用于动态查询对象和对象属性,以及执行操作。 - **AOP**:支持面向切面编程。 - **Aspects**:AOP相关的依赖包。 - **DataAccess/Integration**:封装...

    Spring Cloud Gateway Actuator API SpEL表达式注入命令执行 0day 漏洞复现

    Spring Cloud Gateway 是一款基于Spring Framework和Spring Boot 2.x 的微服务网关,它提供了统一的路由、过滤器以及服务发现等功能,是构建云原生应用的重要组件。Actuator 是 Spring Boot 提供的一个模块,用于...

    最新版spring-framework-4.3.9.RELEASE-schema.zip约束

    6. **lang**:Spring Lang模块提供了一些实用工具类,如反射、类型转换和表达式语言(SpEL),后者允许在运行时动态评估对象和属性。 7. **aop**:面向切面编程(AOP)模块让开发者可以定义横切关注点,如日志、...

    Springtest.rar

    本压缩包"Springtest.rar"显然是一个关于Spring框架IOC特性的实践练习,涵盖了多个关键概念,如属性注入、构造方法注入、集合属性处理、Bean的作用域以及表达式语言(SpEL)、P命名空间和C命名空间的使用。...

Global site tag (gtag.js) - Google Analytics