代理模式有三种:静态代理，动态代理，Cglib代理。
代理模式的功能主要是起到增强方法和权限拦截的作用。
1.静态代理：
其实代理模式根据这个名字就很好理解，举个简单例子：小明要去租房，但他找不到的房东，只能去找中介，中介再帮他找房东，而这个中介就起到了代理的作用。
如图所示：小明的是用户类，调用者，中介就是代理类，房东就是目标类真正需要调用的类，这时代理类就可以在中间做点手脚，起到增强方法的作用。
但有个问题就是如果目标类有很多方法，代理类应该也有这么多方法，这时代理类和目标应该要有一种约定，所以代理类和目标类都应该实现同一个接口。下面是代码实现：
目标类和代理类实现的同一接口，约束规定。
/**
* Created by Ming on 2017/11/25.
*/
public interface LetOutService {
Integer letOut();
}
房东类（目标类）：
/**
* Created by Ming on 2017/11/25.
*/
public class Landlady implements LetOutService {
@Override
public Integer letOut() {
System.out.println("租房方法 running...");
return 100;
}
}
中介类（代理类）：
/**
* Created by Ming on 2017/11/25.
*/
public class Proxy implements LetOutService {
@Override
public Integer letOut() {
Landlady landlady = new Landlady();
Integer integer = landlady.letOut();
return integer + 100;
}
}
用户类：
public class User {
public static void main(String[] args) {
Proxy proxy = new Proxy();
Integer integer = proxy.letOut();
System.out.println(integer);
}
}输出：
2.动态代理：
静态代理缺点：因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多.同时,一旦接口增加方法,目标对象与代理对象都要维护。
解决办法动态代理：其实动态代理和静态代理的思想是不变的，动态代理和静态代理的区别就是，动态代理不用我们去手编写代理类，在运行时，动态的在内存中生产代理类。（字节码对象级别的代理对象）。
动态代理的API：
在java.lang.reflect包中有一个代理类。
- java.lang.reflect.Proxy
static Object |
newProxyInstance(ClassLoader loader,类<?>[] interfaces,InvocationHandler h)
返回指定的接口，将方法调用指定的调用处理程序的代理类的一个实例。
|
返回值：Object就是代理对象
参数：
loader：代表与目标对象相同的类加载器-------目标对象.getClass().getClassLoader()
interfaces：代表与目标对象实现的所有的接口字节码对象数组----数组因为目标类可以有多个接口
h：具体的代理的操作，InvocationHandler接口
注意：JDK的Proxy方式实现的动态代理 目标对象必须有接口 没有接口不能实现jdk版动态代理！
介绍完方法，我们还是以代码为例看看怎么实现吧：
统一接口 ：
/**
* Created by Ming on 2017/11/25.
*/
public interface TargetInterface {
void method1();
void method2();
int method3(Integer i);
}
目标类：
/**
* Created by Ming on 2017/11/25.
*/
public class Target implements TargetInterface {
@Override
public void method1() {
System.out.println("method1 running ...");
}
@Override
public void method2() {
System.out.println("method2 running ...");
}
@Override
public int method3(Integer i) {
System.out.println("method3 running ...");
return i;
}
}
代理工厂类：
/**
* Created by Ming on 2017/11/23.
*/
public class ProxyFactory {
static <T> Object getProxy(T t){
//返回一个代理对象
Object object = Proxy.newProxyInstance(t.getClass().getClassLoader(), t.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// proxy就是目标对象，method就是调用目标对象中方法，args就是调用目标对象中方法的参数。
//比如说：代理对象.method1(),这时proxy就是目标类，method1就是method,args就是method1方法参数。
System.out.println("执行方法前...");
Object invoke = method.invoke(t, args);
System.out.println("执行方法后...");
return invoke;
}
});
return object;
}
}调用者：
/**
* Created by Ming on 2017/11/25.
*/
public class User {
public static void main(String[] args) {
Target target = new Target();
TargetInterface proxy = (TargetInterface)ProxyFactory.getProxy(target);
proxy.method1();
System.out.println("-------------------------");
proxy.method2();
System.out.println("-------------------------");
int i = proxy.method3(100);
System.out.println(i);
}
}
3.Cglib代理：
第三方代理技术,Cglib代理.可以对任何类生成代理.代理的原理是对目标对象进行继承代理。如果目标对象被final修饰.那么该类无法被Cglib代理。
需要引入cglib的jar文件,但是Spring的核心包中已经包括了Cglib功能,所以直接引入spring-core包
代码实现：
目标类 （可以不用实现接口，因为生成的代理类 是目标类的子类）：
/**
* Created by Ming on 2017/11/25.
*/
public class Target {
public void method1() {
System.out.println("method1 running ...");
}
public void method2() {
System.out.println("method2 running ...");
}
public int method3(Integer i) {
System.out.println("method3 running ...");
return i;
}
}
CglibFactory类：
/**
* Created by Ming on 2017/11/25.
*/
public class CglibFactory {
static <T> Object getProxy(T t){
Enhancer en = new Enhancer(); //帮我们生成代理对象
en.setSuperclass(t.getClass());//设置要代理的目标类
en.setCallback(new MethodInterceptor() {//代理要做什么
@Override
public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
System.out.println("执行方法前。。。");
//调用原有方法
Object invoke = methodProxy.invokeSuper(object, args);
// Object invoke = method.invoke(t,args); 作用等同与上面。
System.out.println("执行方法后。。。");
return invoke;
}
});
Object proxyObj = en.create();//生成代理对象
return proxyObj;
}
}调用类:
/**
* Created by Ming on 2017/11/25.
*/
public class User {
public static void main(String[] args) {
Target target = new Target();
TargetInterface proxy = (TargetInterface) CglibFactory.getProxy(target);
System.out.println(proxy.method3(100));
}
}
输出：
案例：
使用动态代理设置全局编码：
public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
resp.setContentType("text/html;charset=utf-8");
HttpServletRequest request = (HttpServletRequest) req;
//使用动态代理 设置全局编码
HttpServletRequest proxyRequest = (HttpServletRequest) Proxy.newProxyInstance(request.getClass().getClassLoader(),
request.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object object, Method method, Object[] args) throws Throwable {
String name = method.getName();
if("getParameter".equals(name)){
String invoke = (String) method.invoke(request, args);
invoke = new String(invoke.getBytes("iso8859-1"),"UTF-8");
return invoke;
}
return method.invoke(request,args);
}
}
);
chain.doFilter(proxyRequest,resp);
}重点：
Spring AOP 编程的实现原理就是 动态代理和Cglib 代理，当目标类实现接口时使用动态代理，没有则Cglib代理。
总结：
静态代理需要自己手动编写代理类和目标方法。
动态代理就不需要自己手动实现代理类和目标方法，但动态代理的目标类要必须实现接口！
Cglib 代理的目标类就不需要实现接口！但目标类不能被final修饰！