Spring AOP
一、AOP的概念
1、AOP：面向切面编程，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各个部分的耦合度降低。提高程序的可重用性，同时提高了开发效率
2、AOP通俗描述：不通过修改源代码的方式进行功能增加。
3、AOP的底层原理：使用JDK的动态代理和CGLIB动态代理
（1）在有接口的情况下 使用JDK动态代理 创建接口的实现类代理对象增强类的方法
（2）在没有接口的情况下 使用CGLIB动态代理 创建子类代理对象增强类的方法
4、AOP术语
（1）连接点 ：类里那些方法可以被增强，这些方法被称为连接点
（2）切入点 ：类里实际被增强的方法，这些方法被称为切入点
（3）通知（增强）：实际增强的逻辑部分称为通知（增强）
通知分5种类型：1、前置通知：方法执行前。2、后置通知：方法执行后。3、环绕通知：方法执行前后。4、异常通知：方法执行异常时。5、最终通知：如finally
（4）切面：把通知应用到切入点的动作
二、AOP的具体使用
1、创建接口UserDao
public interface UserDAO {
public int add(int a, int b);
public String upadate(String name);
}
2、创建实现类
public class UserDaoImpl implements UserDAO {
@Override
public int add(int a, int b) {
return a + b;
}
@Override
public String upadate(String name) {
return name;
}
}
3、创建JDKProxy
public class JDKProxy {
public static void main(String[] args) {
Class[] interfaces = {UserDAO.class};
/* 可以使用匿名对象的方式 也可以使用下面新建实现类的方式
Proxy.newProxyInstance(JDKProxy.class.getClassLoader(),interfaces,new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return null;
}
});*/
UserDaoImpl userDao = new UserDaoImpl();
UserDAO o = (UserDAO)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
int result = o.add(, 2);
System.out.println(result);
}
}
class UserDaoProxy implements InvocationHandler{
//把创建的代理对象传递过来
private Object obj;
public UserDaoProxy(Object obj){//使用构造器进行有参传递
this.obj=obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//方式执行前的操作
System.out.println("方法执行之前" + method.getName() + ":传递参数：" + Arrays.toString(args));
//被增强的方法执行
Object invoke = method.invoke(obj,args);
//方法执行之后的操作
System.out.println("方法之后"+obj);
return invoke;
}
}
三、AOP操作
1、Spring框架一般都是基于AspectJ实现AOP操作
（1）AspectJ不是Spring的组成部分 是独立的AOP框架，一般把AspectJ和Spring一起使用，进行AOP操作
2、AspectJ实现AOP操作
（1）基于xml配置文件实现
（2）基于注解方式实现
3、切入点表达式
（1）切入点表达式作用：知道对哪个类里面的哪个方法进行增强
（2）语法结构： execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]) )
举例1：对com.lianyou.dao.BookDao类里面的add进行增强
execution(* com.lianyou.dao.BookDao.add(..))
举例2：对com.lianyou.dao.BookDao类里面的所有的方法进行增强
execution(* com.lianyou.dao.BookDao.* (..))
举例3：对com.atguigu.dao包里面所有类，类里面所有方法进行增强
execution(* com.atguigu.dao.*.* (..))
4、AspectJ 注解方式
（1）创建类，定义方法
@Component
public class User {
public void add(){
System.out.println("add......");
}
}
（2）创建增强类（编写增强逻辑）
@Component
@Aspect
public class UserProxy {
//前置通知
@Before("execution(* com.lianyou.spring.Proxy.User.add(..))")
public void before(){
System.out.println("before......");
}
//后置通知
@After("execution(* com.lianyou.spring.Proxy.User.add(..))")
public void after(){
System.out.println("after......");
}
//后置通知(返回通知)
@AfterReturning("execution(* com.lianyou.spring.Proxy.User.add(..))")
public void afterReturning(){
System.out.println("afterReturning......");
}
//异常通知
@AfterThrowing("execution(* com.lianyou.spring.Proxy.User.add(..))")
public void afterThrowing(){
System.out.println("afterThrowing......");
}
//环绕通知
@Around("execution(* com.lianyou.spring.Proxy.User.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("around...前...");
proceedingJoinPoint.proceed();
System.out.println("around.....后.");
}
}
（3）配置文件编写
<?xml version=".0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w.org/2001/XMLSchema-instance"
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.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<context:component-scan base-package="com.lianyou.spring.Proxy"></context:component-scan>
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
（4）测试类的编写
@Test
public void testAop(){
ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
User user = context.getBean("user", User.class);
user.add();
System.out.println(user);
}
（5）相同切入点设置
@Pointcut(value = "execution(* com.lianyou.spring.Proxy.User.add(..))")
public void pointCut(){
}
//前置通知
@Before("pointCut()")
public void before(){
System.out.println("before......");
}
（6）设置多个增强类对同一个类进行增强的优先级 使用注解@Order(1) 括号里面的值越大则优先级越小
@Component
@Aspect
@Order()
public class UserProxy {
}
（7）完全注解开发
@Configuration
@ComponentScan(basePackages = {"com.lianyou"}) @EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAop {
}
5、AspectJ XML方式
<?xml version=".0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w.org/2001/XMLSchema-instance"
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.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="book" class="com.lianyou.spring.Book.Book"></bean>
<bean id="bookProxy" class="com.lianyou.spring.Book.BookProxy"></bean>
<aop:config>
<!--配置切入点-->
<aop:pointcut id="p" expression="execution(* com.lianyou.spring.Book.Book.read())"/>
<!--配置切面-->
<aop:aspect ref="bookProxy">
<aop:before method="sleep" pointcut-ref="p"></aop:before>
</aop:aspect>
</aop:config>
</beans>
public class BookProxy {
public void sleep(){
System.out.println("sleep........");
}
}
public class Book {
public void read(){
System.out.println("read。。。。。");
}
}
public void testXML(){ ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml"); Book book = context.getBean("book", Book.class); book.read(); System.out.println(book); }
正文到此结束
相关文章
热门推荐
评论插件初始化中...