标签：java invoke 事物 构造 throw 介绍 事务 获取 proxy
Spring的AOP核心采用的设计模式采用的是代理模式，先介绍下Java的代理。
这里借鉴一下其他人的介绍，https://blog.csdn.net/fighterandknight/article/details/51200470
一 代理模式
代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。
1.静态代理
先定义接口是实现类：
public interface Test{ public void test(); }
public class TestImpl implements Test{ @Override public void test() { System.out.println("测试方法..."); } }
添加代理类：
1 public class TestProxy implements Test{ 2 private TestImpl testImpl; 3 4 /** 5 * 覆盖默认构造器 6 * 7 * 8 */ 9 public TestProxy (TestImpl testImpl) { 10 this.testImpl= testImpl; 11 } 12 13 @Override 14 public void test() { 15 System.out.println("事务处理之前"); 16 // 调用委托类的方法; 17 testImpl.test(); 18 System.out.println("事务处理之后"); 19 } 20 } 21
测试类：
1 public class TestCount { 2 public static void main(String[] args) { 3 TestImpl testImpl = new TestImpl (); 4 TestProxy testProxy = new TestProxy (testImpl ); 5 testProxy.test(); 6 7 } 8 }
2.Jdk动态代理
只能对实现了接口的类生产代理，不能针对类。
定义代理：
1 public class MyInvocationHandler implements InvocationHandler { 2 3 4 //目标对象 5 private Object target; 6 7 /** 8 * 构造方法 9 * @param target 目标对象 10 */ 11 public MyInvocationHandler(Object target) { 12 super(); 13 this.target=target; 14 } 15 16 * 执行目标对象的方法 17 */ 18 public Object invoke(Object proxy, Method method, Object[] args) 19 throws Throwable { 20 21 //在目标方法执行前简单打印一下 22 System.out.println("----------before----------"); 23 24 //执行目标方法对象 25 Object result=method.invoke(target, args); 26 27 //在目标方法执行之后简单打印一下 28 System.out.println("----------after----------"); 29 30 return result; 31 } 32 33 34 /** 35 * 获取目标对象的代理对象 36 * @return 代理对象 37 */ 38 public Object getProxy(){ 39 return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), 40 this.target.getClass().getInterfaces(),this); 41 } 42 43 }
测试类：
1 public class ProxyTest{ 2 3 @Test 4 public void testProxy() throws Throwable{ 5 //实例化目标对象 6 Test test=new TestImpl(); 7 8 //实例化Invocation 9 MyInvocationHandler invocationHandler=new MyInvocationHandler(test); 10 11 //根据目标生成代理对象 12 Test proxy=(Test)invocationHandler.getProxy(); 13 14 //调用代理对象方法 15 proxy.test(); 16 } 17 }
3.cglib代理
cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法，因为采用的是继承，所以不能对final修饰的类进行代理。
定义代理：
1 public class CglibProxy implements MethodInterceptor { 2 private Object target; 3 4 /** 5 * 创建代理对象 6 * 7 * @param target 8 * @return 9 */ 10 public Object getInstance(Object target) { 11 this.target = target; 12 Enhancer enhancer = new Enhancer(); 13 enhancer.setSuperclass(this.target.getClass()); 14 // 回调方法 15 enhancer.setCallback(this); 16 // 创建代理对象 17 return enhancer.create(); 18 } 19 20 @Override 21 // 回调方法 22 public Object intercept(Object obj, Method method, Object[] args, 23 MethodProxy proxy) throws Throwable { 24 System.out.println("事物开始"); 25 proxy.invokeSuper(obj, args); 26 System.out.println("事物结束"); 27 return null; 28 29 30 } 31 32 }
测试类：
public class TestCglib { public static void main(String[] args) { CglibProxy cglib=new CglibProxy (); Testmpl testImpl=(Testmpl)cglib.getInstance(new Testmpl()); testImpl.test(); }
二 Spring Aop
AOP利用一种称为"横切"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。
使用"横切"技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处基本相似，比如权限认证、日志、事物。
Aop中的几个概念：
切面（Aspect） ：官方的抽象定义为“一个关注点的模块化，这个关注点可能会横切多个对象”。
连接点（Joinpoint） ：程序执行过程中的某一行为。
通知（Advice） ：“切面”对于某个“连接点”所产生的动作。
切入点（Pointcut） ：匹配连接点的断言，在AOP中通知和一个切入点表达式关联。
目标对象（Target Object） ：被一个或者多个切面所通知的对象。
AOP代理（AOP Proxy） 在Spring AOP中有两种代理方式，JDK动态代理和CGLIB代理。
作用：
1、降低模块之间的耦合度
2、使系统容易扩展
3、更好的代码复用。
源码太多，就不一一列举了，源码分析可以参考：https://blog.csdn.net/hello_worldee/article/details/78136616
标签：java invoke 事物 构造 throw 介绍 事务 获取 proxy
原文地址：https://www.cnblogs.com/jameszheng/p/10256680.html
