【简记】Java Web 内幕——Spring中AOP的实现

xiaoxiao2021-02-27 259

本章内容： https://www.cnblogs.com/linzhong/p/7234051.html

代理模式静态代理实现动态代理实现（JDK，Cglib），也是Spring底层的实现Spring中的代理实现（利用注解或xml）切入点表达式

####AOP的实现——代理模式代理（Proxy）是一种设计模式，提供了对目标对象另外的访问方式，即通过代理访问目标对象。好处：可以在目标对象实现的基础上，增强额外的功能操作。（扩展目标对象的功能）。

代理模式的关键点：代理对象与目标对象。

####静态代理

可以做到在不修改目标对象的前提下，对目标对象功能扩展静态代理在使用时，需要定义接口或是父类，被代理对象与代理对象一起实现相同的接口或者是继承相同父类。静态代理存在两个缺点 1）代理对象的一个接口只服务于一种类型的对象，如果要代理的方法很多，势必要为每一种方法都进行代理，静态代理在程序规模稍大时就无法胜任了。 2）如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。 /** * 代理对象(静态代理) * 代理对象，要实现与目标对象一样的接口 * @author Jie.Yuan * */ public class UserDaoProxy implements IUserDao{ // 接收保存目标对象 private IUserDao target; public UserDaoProxy(IUserDao target) { this.target = target; } @Override public void save() { // 方法名相同，这样才能保证代理过程对外是透明的 System.out.println("开始事务..."); target.save(); // 执行目标对象的方法 System.out.println("提交事务..."); } }

解决：代理工厂？可以使用动态代理。

####动态代理

动态代理， 1）代理对象，不需要实现接口； 2）代理对象的生成，是利用JDK API，动态的在内存中构建代理对象（需要我们指定创建代理对象/目标对象实现的接口的类型）; 3) 动态代理， JDK代理，接口代理；

package java.lang.reflect; // 反射的包中 public static Object newProxyInstance(ClassLoader loader, // 指定当前目标对象使用类加载器 Class<?>[] interfaces, // 目标对象实现的接口的类型 InvocationHandler h // 事件处理器 )

接口类IUserDao

IUserDao target = new UserDao();

目标对象UserDao

/** * 接口实现 * 目标对象 */ public class UserDao implements IUserDao { public void save() { System.out.println("----保存数据成功!----"); } } import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; /** * * 代理工厂，给所有的dao创建代理对象【动态代理】 * * 代理对象，不需要实现接口 * */ public class ProxyFactory { // 维护一个目标对象 private Object target; public ProxyFactory(Object target){ this.target = target; } // 给目标对象生成代理对象 public Object getProxyInstance() { return Proxy.newProxyInstance( target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("开启事务"); // 执行目标对象方法 Object returnValue = method.invoke(target, args); System.out.println("提交事务"); return returnValue; } }); } } public class App { public static void main(String[] args) { // 目标对象 IUserDao target = new UserDao(); // 【原始的类型 class b.dynamic.UserDao】 System.out.println(target.getClass()); // 给目标对象，创建代理对象 IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance(); // class com.sun.proxy.$Proxy0 内存中动态生成的代理对象 System.out.println(proxy.getClass()); // 执行方法【代理对象】 proxy.save(); } }

动态代理总结：代理对象不需要实现接口，但是目标对象一定要实现接口；否则不能用动态代理！

####Cglib子类代理

如果想代理没有实现接口的类，就可以使用CGLIB实现。

Cglib代理，也叫做子类代理。在内存中构建一个子类对象从而实现对目标对象功能的扩展。（子类继承了父类，也就是被代理对象的所有方法）

CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。

在调用目标方法时，CGLib会回调MethodInterceptor接口方法拦截，来实现你自己的代理逻辑，类似于JDK中的InvocationHandler接口。

public class ProxyFactory implements MethodInterceptor { // 维护目标对象 private Object target; public ProxyFactory(Object target) { this.target = target; } // 给目标对象创建代理对象 public Object getProxyInstance() { //1. 工具类 Enhancer en = new Enhancer(); //2. 设置父类 en.setSuperclass(target.getClass()); //3. 设置回调函数 en.setCallback(this); //4. 创建子类(代理对象) return en.create(); } @Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { System.out.println("开始事务....."); // 执行目标对象的方法 Object returnValue = method.invoke(target, args); System.out.println("提交事务....."); return returnValue; } } public class App { public static void main(String[] args) { // 目标对象 UserDao target = new UserDao(); // class class c.cglib.UserDao System.out.println(target.getClass()); // 代理对象 UserDao proxy = (UserDao) new ProxyFactory(target).getProxyInstance(); // UserDao子类：class c.cglib.UserDao$$EnhancerByCGLIB$$e3ae3440 System.out.println(proxy.getClass()); // 执行代理对象的方法 proxy.save(); } }

总结： 1）代理的类不能为final，否则报错（因为无法生成子类）。 2）目标对象的方法如果为final/static, 那么就不会被拦截，即不会执行目标对象额外的业务方法。

在Spring的AOP编程中，如果加入容器的目标对象有实现接口，用JDK代理；如果目标对象没有实现接口，用Cglib代理；

####手动实现AOP编程

AOP可以实现“业务代码”与“关注点代码”分离。

try { session = HibernateSessionFactoryUtils.getSession(); // 【关注点代码】 trans = session.beginTransaction(); // 【关注点代码】 session.save(user); // 核心业务代码 trans.commit(); //…【关注点代码】 }

分析总结：关注点代码，就是指重复执行的代码。业务代码与关注点代码分离，好处？

关注点代码写一次即可；开发者只需要关注核心业务；运行时期，执行核心业务代码时候动态织入关注点代码；【代理】 public class ProxyFactory { // 目标对象 private static Object target; private static Aop aop; // 生成代理对象的方法 public static Object getProxyInstance(Object target_,Aop aop_){ target = target_; aop = aop_; return Proxy.newProxyInstance( target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { aop.begin();// 执行重复代码 // 执行目标对象的方法 Object returnValue = method.invoke(target, args); aop.commite(); // 执行重复代码 return returnValue; } }); } }  <bean id="userDao_proxy" class="d.myaop.ProxyFactory" factory-method="getProxyInstance"> <constructor-arg index="0" ref="userDao"></constructor-arg> <constructor-arg index="1" ref="aop"></constructor-arg> </bean>

####注解方式实现AOP编程切面：关注点形成的类，就叫切面(类)！面向切面编程，就是指对很多功能都有的重复的代码抽取，再在运行的时候往业务方法上动态植入“切面类代码”。

切入点：执行目标对象方法，动态植入切面代码。可以通过切入点表达式，指定拦截哪些类的哪些方法；给指定的类在运行的时候植入切面类代码。

@Component @Aspect // 指定当前类为切面类 public class Aop { // 指定切入点表单式：拦截哪些方法；即为哪些类生成代理对象 @Pointcut("execution(* e.aop.*.*(..))") // *:通配符, （..)代表任意参数 public void pointCut_(){ } // 前置通知 : 在执行目标方法之前执行 @Before("pointCut_()") public void begin(){ System.out.println("开始事务/异常"); } // 后置/最终通知：在执行目标方法之后执行【无论是否出现异常最终都会执行】 @After("pointCut_()") public void after(){ System.out.println("提交事务/关闭"); } // 返回后通知：在调用目标方法结束后执行【出现异常不执行】 @AfterReturning("pointCut_()") public void afterReturning() { System.out.println("afterReturning()"); } // 异常通知：当目标方法执行异常时候执行此关注点代码 @AfterThrowing("pointCut_()") public void afterThrowing(){ System.out.println("afterThrowing()"); } // 环绕通知：环绕目标方式执行 @Around("pointCut_()") public void around(ProceedingJoinPoint pjp) throws Throwable{ System.out.println("环绕前...."); pjp.proceed(); // 执行目标方法 System.out.println("环绕后...."); } } public class App { ApplicationContext ac = new FileSystemXmlApplicationContext("E:/mavenspring/src/main/java/e/aop/bean.xml"); // 目标对象有实现接口，spring会自动选择“JDK代理” @Test public void testApp() { IUserDao userDao = (IUserDao) ac.getBean("userDao"); System.out.println(userDao.getClass());//$Proxy001 userDao.save(); } // 目标对象没有实现接口， spring会用“cglib代理” @Test public void testCglib() { OrderDao orderDao = (OrderDao) ac.getBean("orderDao"); System.out.println(orderDao.getClass()); orderDao.save(); } @Deprecated // 共性问题：如果目标对象有实现接口，在从容器中获取目标对象的时候，只能通过接口接收对象。 public void testApp2() { // 错误代码：只能用接口接收 UserDao userDao = (UserDao) ac.getBean("userDao"); System.out.println(userDao.getClass());//$Proxy001 userDao.save(); } @Test public void testGetObj() throws Exception { OrderDao orderDao1 = (OrderDao) ac.getBean("orderDao"); OrderDao orderDao2 = (OrderDao) ac.getBean("orderDao"); System.out.println(orderDao1); System.out.println(orderDao2); } }

@Aspect 指定一个类为切面类 @Pointcut(“execution(* cn.itcast.e_aop_anno..(…))”) 指定切入点表达式

@Before(“pointCut_()”) 前置通知: 目标方法之前执行 @After(“pointCut_()”) 后置通知：目标方法之后执行（始终执行） @AfterReturning(“pointCut_()”) 返回后通知：执行方法结束前执行(异常不执行) @AfterThrowing(“pointCut_()”) 异常通知: 出现异常时候执行 @Around(“pointCut_()”) 环绕通知：环绕目标方法执行

####XML方式实现AOP编程 1）引入aop名称空间 2）aop 配置 * 配置切面类（重复执行代码形成的类） * aop配置拦截哪些方法 / 拦截到方法后应用通知代码

--------------------------xml配置文件-------------------------------- <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" ---------------声明aop命名空间------------------- 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="userDao" class="cn.itcast.f_aop_xml.UserDao"></bean> <bean id="orderDao" class="cn.itcast.f_aop_xml.OrderDao"></bean>  <bean id="aop" class="cn.itcast.f_aop_xml.Aop"></bean>  <aop:config>  <aop:pointcut expression="execution(* cn.itcast.f_aop_xml.*.*(..))" id="pt"/>  <aop:aspect ref="aop">  <aop:around method="around" pointcut-ref="pt"/>  <aop:before method="begin" pointcut-ref="pt"/>  <aop:after method="after" pointcut-ref="pt"/>  <aop:after-returning method="afterReturning" pointcut-ref="pt"/>  <aop:after-throwing method="afterThrowing" pointcut-ref="pt"/> </aop:aspect> </aop:config> </beans>

####切入点表达式

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern) throws-pattern?) 修饰符（可选），返回类型，描述类型（可选），方法名，（参数类型），异常类型（可选）

All parts except the returning type pattern (ret-type-pattern in the snippet above), name pattern, and parameters pattern are optional.

<aop:pointcut expression=" not execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>

转载请注明原文地址: https://www.6miu.com/read-9914.html

技术

最新回复(0)