spring第4天(通过构造方法注入值,给各种类型属性注入值,AOP)

一,通过构造方法注入值

通过有参构造进行值的注入（注入的类需要有有参构造方法）

<bean id="dao" class="dao.Impl.UserDaoImpl"></bean>

<bean id="service" class="service.Impl.UserServiceImpl">
<!-- 通过setXXX方法进行值的注入 -->
<!-- <property name="userDao" ref="dao"></property> -->
	<!-- 通过有参构造进行值得注入 -->
	<constructor-arg>
	<ref bean="dao"/>
	</constructor-arg>
</bean>

二,给类中的不同类型的属性注入值

1. 特殊字符"&"
   使用&

<property name="str1">
	<value>马&amp;儿</value>
</property>

使用

<property name="str2">
	<value><![CDATA[马&儿]]></value>
</property>

2. 给对象注入值
   使用ref或者内部注入

<property name="user">
	<bean class="entity.User">
		<property name="name" value="admin"></property>
	</bean>
</property>

3. 注入list集合
   使用list标签

<property name="list">
	<list>
		<value>足球</value>
		<value>篮球</value>
	</list>
</property>

4. 注入数组
   使用array标签

<property name="str">
	<array>
		<value>面</value>
		<value>饭</value>
	</array>
</property>

5. 注入set集合
   使用set标签

<property name="set">
	<set>
		<value>矿泉水</value>
		<value>娃哈哈</value>
	</set>
</property>

6. 注入map集合
   每个键值对都需要使用entry标签包含,键使用key包含value,值使用value

<property name="map">
	<map>
		<entry>
			<key>
				<value>gf</value>
			</key>
			<value>高尔夫</value>

		</entry>
		<entry>
			<key>
				<value>bq</value>
			</key>
			<value>棒球</value>
		</entry>
	</map>
</property>

7. 注入property,配置文件的属性,类似于map集合
   使用props标签包含婆婆标签,key值写在key后,value值写在pro标签中间

<property name="pops">
	<props>
		<prop key="user">root</prop>
		<prop key="pass">1234</prop>
	</props>
</property>

8. 注入空值
   value不给值,但是value标签必须要

<property name="empty">
	<value></value>
</property>

9. 注入null值
   使用null标签

<property name="nullValue">
	<null></null>	</property>

三,AOP:面向切面编程

AOP就是在不改变原来代码的基础上新增功能的(增强)
需要创建增强方法

专业术语

1. 切面(Aspect)
2. 连接点(Join Point)
3. 增强处理(Advice)
4. 切入点(Pointcut)
5. 目标对象(Target Object)
6. AOP代理(AOP Proxy)
7. 织入(Weaving)

配置切面

定义切入点(可以是方法) id:切入点的名称 expression:定义一个切入点的表达式(匹配某些类中的某些方法,可以是一个模糊匹配)
模糊匹配:例如切入ServiceImpl中的saveUser()方法
1,public void saveUser(entity.User)
2,public * saveUser(entity.User)
3,public void saveUser(entity.User)
4, service..(..):匹配service包下面的所有类所有方法
5,* service...(..):匹配service包和他的子包下面的所有方法

增强方式

1. 前置增强:aop:before
2. 后置增强:aop:after-returning
3. 最终增强:aop:after
4. 环绕增强:aop:around
5. 异常增强:aop:throwwing
   属性说明:

• method属性:对应的是增强的方法名
• pointcut-ref:指向的是连接点
• returning:指定返回值到那个变量上(是在注入返回值到result变量)

重点:AOP步骤

1. 创建增强类,类中创建增强方法

说明:JoinPoint jp是切入点参数
getTarget():获取目标方法所在的类
getSignature().getName():获取目标方法名
Arrays.toString(jp.getArgs()):获取目标方法中的参数

2. 在配置文件中配置AOP(需要AOP的jar包),然后创建增强类的对象

<!-- 创建UserAop对象 -->
<bean id="userAop" class="aop.UserAop"/>

3. 配置切面

<aop:config>
	<aop:pointcut expression="execution(public void saveUser(entity.User))" id="pointcut" />
		<!-- 引入包含增强方法的类对象 -->
		<aop:aspect ref="userAop" >
			<!-- 指定前置增强的方法 -->
			<aop:before method="before" pointcut-ref="pointcut"/>
			<!-- 指定后置增强的方法 -->
			<aop:after-returning method="afterReturning" pointcut-ref="pointcut" returning="result"/>
		</aop:aspect>
</aop:config>

3.1 配置切面
使用aop:config标签,其他配置全部写在里面
3.2 定义切入点

<aop:pointcut expression="execution(public void saveUser(entity.User))" id="pointcut" />

注意:

• aop:pointcut标签中的expression属性接的是需要增强的方法,可以使用模糊匹配,如下
  1,public void saveUser(entity.User)
  2,public * saveUser(entity.User)
  3,public void saveUser(entity.User)
  4, service..(..):匹配service包下面的所有类所有方法
  5,* service...(..):匹配service包和他的子包下面的所有方法
• aop:pointcut标签中的id属性代表切入点,下面配置将会用到

3.3 引入包含增强类的对象
注意:ref属性需要指向一个步骤2中创建好的增强类的对象

<aop:aspect ref="userAop" >
增强方法的配置写在中间
</aop:aspect>

3.4 指定增强方法
注意1:

• method代表增强方法名
• pointcut-ref属性代表切入点
• returning属性代表返回值

注意2:增强方式有如下五种

• aop:before:前置增强;
  

• aop:after-returning:后置增强;
  

• aop:after:最终增强(相当于finally,不管怎么样都会执行的增强,抛异常了也会执行);
  

• aop:around:环绕增强(环绕增强是最强大的增强,因为spring容器将目标方法的控制权全部都交给了他,可以做到其他四个增强能做到的事)
  proceed():决定是否执行目标方法,如果没有这个,就不会执行目标方法
  proceed(Object[] args):决定是否执行目标方法的同时,是否改变当中的参数;
  

• aop:throwwing:异常增强(有异常时才会执行);
  

<!-- 指定前置增强的方法 -->
<aop:before method="before" pointcut-ref="pointcut"/>
<!-- 指定后置增强的方法 -->
<aop:after-returning method="afterReturning" pointcut-ref="pointcut" returning="result"/>
<!-- 指定异常增强 -->
<aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="e"/> 
<!-- 指定最终增强:相当于finally,不管怎么样都会执行的增强,抛异常了也会执行 -->
<aop:after method="after" pointcut-ref="pointcut" />
<!-- 指定环绕增强的方法 -->
<aop:around method="around" pointcut-ref="pointcut" />

AOP总体配置如下: