spring-02注解和aop（重点篇）

1.注解

1>装配：<bean name="user" class="com.imwj.domain.User"  />作用的注解

@Component("user")：普通注解，写在类名上（下同）

@Service("user") ：service层

@Controller("user")：web层

@Repository("user")：dao层

指定对象的作用范围：@Scope(scopeName="singleton")

//@Component("user")，@Service("user") service层，@Controller("user") web层
@Repository("user")// dao层
//指定对象的作用范围
@Scope(scopeName="singleton")
public class User {

 

2>注入：<property name="name" value="布加迪威龙" ></property>作用的注解

普通注入：@Value("tom")：写在声明属性上（通过反射来注入）或set上（通过set方法注入），后者常用

引用注入（ref）：@Autowired根据类型自动装配（多个相同类型时会出错），@Qualifier("car")根据名称自动装配，Resource(name="car")手动装配

@Value("18")
	private Integer age;
@Value("tom")	
	public void setName(String name) {

 

3>生命周期

@PostConstruct ：在对象被创建后调用.init-method，写在要执行的方法上（下同）

@PreDestroy ：在销毁之前调用.destory-method

@PostConstruct //在对象被创建后调用.init-method
	public void init(){
@PreDestroy //在销毁之前调用.destory-method
        public void destory(){

 

提一个eclipse的spring插件：springsource Tool Suite（STS）

 

4>spring整合junit测试

导包：4（基础包）+2（日志包）+aop+test

配置注解使用：

//帮我们创建容器
@RunWith(SpringJUnit4ClassRunner.class)
//指定创建容器时使用哪个配置文件
@ContextConfiguration("classpath:applicationContext.xml")
public class Demo {
	//将名为user的对象注入到u变量中
	@Resource(name="user")
	private User user;
	
	@Test
	public void fun1(){
		System.out.println(user);	
	}

 

2.spring中的aop

1>aop：面向切面编程

spring能够为容器中管理的对象生成动态代理对象，在之前我们需要使用Proxy.newProxyInstance（xx,xx,xx）而spring能够帮我们生成代理对象（我们直接使用即可）

 

2>spring实现aop的原理

动态代理（优先）：被代理对象必须要实现接口，才能产生代理对象，如果没有接口将不能使用动态代理技术，详情请见：https://blog.csdn.net/langao_q/article/details/81413769

cglib代理（没有接口）：第三方代理技术，cglib代理可以对任何类产生代理，原理是对目标对象进行继承代理，如果目标对象被final修饰那么该类就无法被cglib代理

 

3>aop代理名词

Joinpoint（连接点）：目标对象中，所有可以增强的方法

Pointcut（切入点）：目标对象中，已经增强的方法

Advice（通知/增强）：增强/通知的代码

Target（目标对象）：被代理的对象

Weaving（织入）：将通知应用到切入点的过程

Proxy（代理）：将通知织入目标对象后，形成代理对象

aspect（切面）：切入点+通知

 

4>aop实现（xml配置 / 注解配置）（划重点）

1.导包：4+2+2（aop+aspects）+spring第三方aop（2个）

2.目标对象：

//目标对象：需要实现一个接口
public class UserServiceImpl implements UserService {
	@Override
	public void save() {
		System.out.println("保存用户!");
		//int i = 1/0;//制造异常来测试后一个后置通知
	}
	@Override
	public void delete() {    System.out.println("删除用户!");    }
	@Override
	public void update() {    System.out.println("更新用户!");    }
	@Override
	public void find() {    System.out.println("查找用户!");    }
}

3.准备通知：

//通知类
public class MyAdvice {
	//前置通知
	public void before(){    System.out.println("这是前置通知!!");    }
	//后置通知
	public void afterReturning(){    System.out.println("这是后置通知(如果出现异常不会调用)!!");    }
	//环绕通知
	public Object around(ProceedingJoinPoint pjp) throws Throwable {
		System.out.println("这是环绕通知之前的部分!!");
		Object proceed = pjp.proceed();//调用目标方法
		System.out.println("这是环绕通知之后的部分!!");
		return proceed;
	}
	//异常通知
	public void afterException(){    System.out.println("出事啦!出现异常了!!");    }
	//后置通知
	public void after(){    System.out.println("这是后置通知(出现异常也会调用)!!");    }
}

4.配置进行织入，将通知织入目标对象中（重点）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd ">

<!-- 准备工作: 导入aop(约束)命名空间 -->
<!-- 1.配置目标对象 -->
	<bean name="userService" class="com.imwj.service.UserServiceImpl" ></bean>
<!-- 2.配置通知对象 -->
	<bean name="myAdvice" class="com.imwj.springaop.MyAdvice" ></bean>
<!-- 3.配置将通知织入目标对象 -->
	<aop:config>
		<!-- 配置切入点
           第一个*：返回值类型；第二个*：service下的所有以ServiceImpl结尾的类
            第三个*：类中的所有方法；第四个..：方法需要传入任意参数
        -->
		<aop:pointcut expression="execution(* com.imwj.service.*ServiceImpl.*(..))" id="pc"/>
		<aop:aspect ref="myAdvice" >
			<!-- 指定名为before方法作为前置通知 -->
			<aop:before method="before" pointcut-ref="pc" />
			<!-- 后置 -->
			<aop:after-returning method="afterReturning" pointcut-ref="pc" />
			<!-- 环绕通知 -->
			<aop:around method="around" pointcut-ref="pc" />
			<!-- 异常拦截通知 -->
			<aop:after-throwing method="afterException" pointcut-ref="pc"/>
			<!-- 后置 -->
			<aop:after method="after" pointcut-ref="pc"/>
		</aop:aspect>
	</aop:config>
</beans>

前置通知：在目标方法运行之前会调用

后置通知（出现异常不会调用）：在目标方法运行之后会调用

环绕通知：在目标运行之前 / 之后都会调用

异常拦截通知：出现异常时会调用

后置通知（出现异常也会调用）：在目标方法运行之后会调用

 

注解配置：（不常用）

//通知类
@Aspect
//表示该类是一个通知类
public class MyAdvice {
	@Pointcut("execution(* com.imwj.service.*ServiceImpl.*(..))")
	public void pc(){}
	//前置通知
	//指定该方法是前置通知,并制定切入点
	@Before("MyAdvice.pc()")
	public void before(){
		System.out.println("这是前置通知!!");
	}
	//后置通知
	@AfterReturning("execution(* com.imwj.service.*ServiceImpl.*(..))")
	public void afterReturning(){
		System.out.println("这是后置通知(如果出现异常不会调用)!!");
	}
	//环绕通知
	@Around("execution(* com.imwj.service.*ServiceImpl.*(..))")
	public Object around(ProceedingJoinPoint pjp) throws Throwable {
		System.out.println("这是环绕通知之前的部分!!");
		Object proceed = pjp.proceed();//调用目标方法
		System.out.println("这是环绕通知之后的部分!!");
		return proceed;
	}
	//异常通知
	@AfterThrowing("execution(* com.imwj.service.*ServiceImpl.*(..))")
	public void afterException(){
		System.out.println("出事啦!出现异常了!!");
	}
	//后置通知
	@After("execution(* com.imwj.service.*ServiceImpl.*(..))")
	public void after(){
		System.out.println("这是后置通知(出现异常也会调用)!!");
	}
}

 

 

总结：

一.注解代替xml配置
	准备工作:
		4+2 + spring-aop包
		xml中导入context约束
		在xml中开启扫描包中类的注解
	注解:
		@Component("BeanName") 将对象注册到spring容器
			|-	@Controler
			|-	@Service
			|-	@Repository
		
		@Scope	指定对象的作用范围
			|- singleton
			|- prototype
			
		@Value 值类型属性注入
			
		@Autowired 自动属性注入.根据类型注入.
		@Qulifier 指定注入的对象的名称
		
		@Resource 指定对象的名称注入
		
		@PostConstruct 初始化方法
		@PreDestory    销毁方法

二.spring AOP开发
		aop思想: 纵向重复,横向抽取.
			|- filter中
			|- 动态代理
			|- interceptor中
			
		spring AOP: 封装了动态代理技术.来体现aop.

		
		springaop实现: 	可以对所有对象进行代理
				|- 动态代理	 代理需要实现接口.
				|- cglib代理 对目标对象继承代理.
		
		springaop名词:
				join point: 连接点.所有可以织入通知的方法.
				point cut : 切入点.需要|已经织入通知的方法.
				advice:		需要增强的代码.
				weaving:	动词.将通知应用的切点的过程.
				target: 目标对象.
				proxy:	代理对象
				aspect: 切面. 切入点+通知
				
		步骤:
			1.导包
				4+2
				2 aop+aspect
				2 aop联盟+weaving
			2.准备目标对象

			3.准备通知类
				 前置通知
				 后置通知 方法正常结束
				 环绕通知
				 异常拦截通知
				 后置通知 无论如何都执行
		
			4.配置文件中配置,导入aop约束
				1>目标对象
				2>通知对象
				3><aop:config>
						<aop:ponint-cut id="切点名称" expression="execution(切点表达式)" />
						<aop:aspect ref="通知对象名称" >
							<aop:before method="" ponintcut-ref=""  />
							<aop:after-returning method="" ponintcut-ref=""  />
							<aop:around method="" ponintcut-ref=""  />
							<aop:after-throwing method="" ponintcut-ref=""  />
							<aop:after method="" ponintcut-ref=""  />
						</aop:aspect>
	
		扩展:使用注解完成aop
			1.导包
				4+2
				2 aop+aspect
				2 aop联盟+weaving
			2.准备目标对象
			3.准备通知类
			4.配置文件中配置,导入aop约束
				1>目标对象
				2>通知对象
				3><aop:aspect-autoproxy> 开启注解aop	
			5.注解
				@Aspect 指定当前类是通知类
				
				@Before 前置通知方法
				@after-returning 后置通知方法
				@around 环绕通知方法
				@after-throwing 异常拦截通知方法
				@after 后通知方法
				
				@PointCut 抽取切点表达式