静态代理在使用时，需要定义接口或者父类，被代理对象（即目标对象）与代理对象一起实现相同的接口或者继承相同父类。
应用步骤：
注意：代理对象与被代理对象/目标对象要实现相同的接口，然后通过调用相同的方法来调用目标对象的方法。
类图：
定义一个接口：ITeacherDao
package com.csu.marden.staticproxy;
public interface ITeacherDao {
public void teach();
}
被代理对象/目标对象TeacherDao实现接口ITeacherDao
package com.csu.marden.staticproxy;
public class TeacherDao implements ITeacherDao{
@Override
public void teach() {
System.out.println(" 老师授课中... ");
}
}使用静态代理方式，就需要在代理对象TeacherDaoProxy中实现接口ITeacherDao
package com.csu.marden.staticproxy;
public class TeacherDaoProxy implements ITeacherDao{
//目标对象，通过接口来聚合
private ITeacherDao target;
//构造器，将目标对象传入到代理对象
public TeacherDaoProxy(ITeacherDao target) {
this.target = target;
}
@Override
public void teach() {
System.out.println(" 代理开始... ");
target.teach();
System.out.println(" 代理结束... ");
}
}
调用的时候通过调用代理对象的方法来调用被代理对象/目标对象
package com.csu.marden.staticproxy;
public class Client {
public static void main(String[] args) {
//创建被代理对象/目标对象
ITeacherDao target=new TeacherDao();
//创建代理对象，同时将被代理对象传入到代理对象中
ITeacherDao proxy=new TeacherDaoProxy(target);
//通过代理对象，调用被代理对象的方法
proxy.teach();
}
}
静态代理优缺点：
优点：在不修改目标对象的功能前提下，能通过代理对象对目标功能扩展
缺点：因为代理对象需要与目标对象实现一样的接口，所以会有很多代理类；而且一旦接口增加新的方法，目标对象与代理对象都要维护
动态代理中的代理对象不需要实现接口，但是目标对象需要实现接口，否则无法使用动态代理。
代理对象的生成，是利用JDK的API，动态地在内存中构建代理对象
JDK动态代理也叫接口代理
JDK中生成代理对象的API:（一个Proxy类和一个InvocationHandler接口）
（1）Proxy类：代理类所在的包：java.lang.reflect.Proxy，该类用于动态生成代理对象，只需要传入目标接口，目标接口的类加载器以及InvocationHandler，便可为目标接口生成代理类以及代理对象
（2）Proxy中的newProxyInstance方法，该方法需要接收三个参数：
static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) //第一个参数：用哪个类加载器去加载代理对象，定义了由哪个classloader对象对生成的代理类进行加载 //第二个参数：一个interface对象数组，表示我们将要给我们的代理对象提供一组什么样的接口，如果我们提供了这样一个接口对象数组，那么也就是声明了代理类实现了这些接口，代理类就可以调用接口中声明的所有方法 //第三个参数：一个InvocationHandler对象，表示的是当动态代理对象调用方法的时候会关联到哪一个InvocationHandler对象上，并最终由其调用（3）InvocationHandler接口：是proxy代理对象的调用处理程序实现的一个接口，每一个proxy代理对象都有一个关联的调用处理程序；在代理对象调用方法时，方法调用被编码分派到调用处理程序的invoke方法。每一个动态代理类的调用处理程序都必须实现InvocationHandler接口，并且每个代理类的对象都关联到了实现该接口的动态代理类调用处理程序中，当我们通过动态代理对象调用一个方法的时候，这个方法的调用就会被转发到实现InvocationHandler接口类的invoke方法来调用
（4）InvocationHandler接口中的invoke方法，该方法需要接收三个参数：public Object invoke(Object proxy, Method method, Object[] args) //第一个参数：代理类代理的目标对象 //第二个参数：我们所要调用某个对象真实的方法的Method对象 //第三个参数：指代代理对象方法传递的参数
实例：将上述静态代理改写为JDK动态代理
类图：
定义一个接口：ITeacherDao
package com.csu.marden.jdkdynamicproxy;
public interface ITeacherDao {
public void teach();
}
被代理对象/目标对象TeacherDao实现接口ITeacherDao
package com.csu.marden.jdkdynamicproxy;
public class TeacherDao implements ITeacherDao{
@Override
public void teach() {
System.out.println(" 老师授课中... ");
}
}
使用动态代理方式，生成目标对象的代理对象
package com.csu.marden.jdkdynamicproxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class ProxyFactory {
//维护一个目标对象target
private Object target;
//构造器，将目标对象传入
public ProxyFactory(Object target) {
super();
this.target = target;
}
//给目标对象生成一个代理对象
public Object getProxyInstance(){
//public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
//参数说明：
//第一个参数：ClassLoader loader：指定当前目标对象使用的类加载器
//第二个参数：Class<?>[] interfaces：目标对象实现的接口(数组形式)
//第三个参数：InvocationHandler h：事件处理，执行目标对象的方法时，会触发事件处理器方法，会把当前执行的目标对象的方法作为参数传入
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(" JDK代理开始... ");
//通过反射机制调用目标对象的方法
Object returnValue =method.invoke(target, args);
System.out.println(" JDK代理结束... ");
return returnValue;
}
});
}
}
调用的时候通过调用代理对象的方法来调用被代理对象/目标对象
package com.csu.marden.jdkdynamicproxy;
public class Client {
public static void main(String[] args) {
//创建目标对象
ITeacherDao target=new TeacherDao();
//给定目标对象，创建代理对象
ITeacherDao proxyInstance = (ITeacherDao) new ProxyFactory(target).getProxyInstance();
//内存中动态生成了代理对象
System.out.println(proxyInstance.getClass());
//通过代理对象，调用目标对象的方法
proxyInstance.teach();
}
}
参考链接：
https://blog.csdn.net/yaomingyang/article/details/80981004
https://blog.csdn.net/yaomingyang/article/details/81040390
静态代理和JDK动态代理都要求目标对象实现一个接口，但是有的时候，目标对象只是一个单独的对象，并没有实现任何的接口，这个时候可以使用目标对象子类来实现代理，这就是Cglib代理
Cglib代理也叫子类代理，它是在内存中构建一个子类对象，从而实现对目标对象功能扩展
Cglib是一个强大的高性能的代码生成包，其底层是通过使用字节码处理框架ASM来转换字节码并生成新的类，它可以在运行期扩展Java类，实现Java接口，它广泛的被许多AOP框架使用，例如Spring AOP，用以提供方法拦截操作
在AOP变成中如何选择代理模式：目标对象需要实现接口，用JDK代理；目标对象不需要实现接口，用Cglib代理
使用步骤：
引入Cglib的jar包
类图：
被代理对象/目标对象TeacherDao
package com.csu.marden.cglibdynamicproxy;
public class TeacherDao {
public void teach(){
System.out.println(" 老师授课中... ");
}
}
使用Cglib动态代理方式，生成目标对象的代理对象
package com.csu.marden.cglibdynamicproxy;
import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class ProxyFactory implements MethodInterceptor{
//维护一个目标对象
private Object target;
//构造器，将目标对象传入
public ProxyFactory(Object target) {
this.target = target;
}
//返回一个代理对象，即target对象的代理对象
public Object getProxyInstance(){
//1.创建一个工具类
Enhancer enhancer=new Enhancer();
//2.设置父类
enhancer.setSuperclass(target.getClass());
//3.设置回调函数
enhancer.setCallback(this);
//4.创建子类对象，即代理对象
return enhancer.create();
}
//重写intercept方法，会调用目标对象的方法
@Override
public Object intercept(Object arg0, Method method, Object[] arg2, MethodProxy arg3) throws Throwable {
System.out.println(" Cglib代理开始... ");
Object returnValue=method.invoke(target, arg2);
System.out.println(" Cglib代理结束... ");
return returnValue;
}
}
调用的时候通过调用代理对象的方法来调用被代理对象/目标对象
package com.csu.marden.cglibdynamicproxy;
public class Client {
public static void main(String[] args) {
//创建目标对象
TeacherDao target=new TeacherDao();
//获取到代理对象，并且将目标对象传递给代理对象
TeacherDao proxy = (TeacherDao) new ProxyFactory(target).getProxyInstance();
//执行代理对象的方法，出发intecept方法，从而实现对目标对象的调用
proxy.teach();
}
}
（1）JDK动态代理只能够对接口进行代理，不能对普通的类进行代理；而Cglib动态代理可以代理普通类
（1）JDK动态代理使用Java原生的反射API进行操作，在生成类上比较高效；而Cglib动态代理使用ASM框架直接对字节码进行操作，在类的执行过程中比较高效
AOP（Aspect Oriented Programming），面向切面编程，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
AOP的通俗描述：不通过修改源代码方式，在主干功能里面添加新功能。
使用登陆案例说明AOP：原有的登陆流程通过获取用户输入的用户名和密码，与数据库中已有信息进行比对，如果比对结果不一致，则登陆失败，返回登陆页面；如果比对结果一致，则登陆成功，进入系统主页面。要想在原有的功能基础上添加权限判断功能，原始的方式是通过修改源代码实现。现在想要不修改源代码，并且添加新的功能，就使用AOP技术。
AOP底层使用动态代理，有两种情况的动态代理：
第一种：有接口的情况，使用JDK动态代理（创建接口实现类代理对象，增强类的方法）
第二种情况：没有接口的情况，使用Cglib动态代理（创建子类的代理对象，增强类的方法）
