-
核心作用：
- 通过代理，控制对象的访问
- 可以详细控制访问
某个（某类）对象的方法，在调用这个方法前做前置处理，调用这个方法后做后置处理。（即：AOP的微观实现）
-
AOP(Aspect Oriented Programming面向切面编程)的核心实现机制
-
核心角色：
- 抽象角色
- 定义代理角色和真实角色的公共对外方法
- 真实角色
- 实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。
关注真实的业务逻辑！
- 代理角色
- 实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。
将统一的流程控制放到代理角色中处理
- 抽象角色
-
应用场景：
- 安全代理：屏蔽对真实角色的直接访问。
- 远程代理：通过代理类处理远程方法调用(RMI)
- 延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象。
- 比如你要开发一个大文档查看软件，大文档中大的图片，又可能一个图片有100MB，在打开文件时不可能将所有的图片都显示出来，这样就可以使用代理模式，当需要查看图片时，用proxy来进行大图片的打开。
-
分类：
- 静态代理(静态定义代理类)
- 动态代理(动态生成代理类)
- JDK自带的动态代理
- javaassist字节码操作库实现
- CGLIB
- ASM(底层使用指令，可维护性较差)
-
静态代理(静态定义代理类)static proxy
案例一
package com.bjsxt.proxy.staticProxy;
public interface Star {
/**
* 面谈
*/
void confer();
/**
* 签合同
*/
void signContract();
/**
* 订票
*/
void bookTicket();
/**
* 唱歌
*/
void sing();
/**
* 收钱
*/
void collectMoney();
}
package com.bjsxt.proxy.staticProxy;
public class ProxyStar implements Star {
private Star star;
public ProxyStar(Star star) {
super();
this.star = star;
}
@Override
public void bookTicket() {
System.out.println("ProxyStar.bookTicket()");
}
@Override
public void collectMoney() {
System.out.println("ProxyStar.collectMoney()");
}
@Override
public void confer() {
System.out.println("ProxyStar.confer()");
}
@Override
public void signContract() {
System.out.println("ProxyStar.signContract()");
}
@Override
public void sing() {
star.sing();
}
}
package com.bjsxt.proxy.staticProxy;
public class RealStar implements Star {
@Override
public void bookTicket() {
System.out.println("RealStar.bookTicket()");
}
@Override
public void collectMoney() {
System.out.println("RealStar.collectMoney()");
}
@Override
public void confer() {
System.out.println("RealStar.confer()");
}
@Override
public void signContract() {
System.out.println("RealStar.signContract()");
}
@Override
public void sing() {
System.out.println("RealStar(周杰伦本人).sing()");
}
}
package com.bjsxt.proxy.staticProxy;
public class Client {
public static void main(String[] args) {
Star real = new RealStar();
Star proxy = new ProxyStar(real);
proxy.confer();
proxy.signContract();
proxy.bookTicket();
proxy.sing();
proxy.collectMoney();
}
}
案例二
package com.qfedu.proxy;
public interface LawSuit {
void submit(String proof);//起诉
void defend();//法庭辩护
}
package com.qfedu.proxy;
public class ProxyLawer implements LawSuit{
LawSuit lawSuit;//被代理对象
//new ProxyLawer(new GouDan());
public ProxyLawer(LawSuit lawSuit) {
this.lawSuit = lawSuit;
}
@Override
public void submit(String proof) {
lawSuit.submit(proof);
}
@Override
public void defend() {
lawSuit.defend();
}
}
package com.qfedu.proxy;
public class GouDan implements LawSuit{
@Override
public void submit(String proof) {
System.out.println("老板带着小姨子跑路了,欠我钱，证据如下" + proof);
}
@Override
public void defend() {
System.out.println("铁证如山，奇元还钱");
}
}
package com.qfedu.proxy;
public class ProxyFactory {
public static LawSuit getProxy() {
return new ProxyLawer(new GouDan());
}
}
package com.qfedu.proxy;
public class Demo {
public static void main(String[] args) {
ProxyFactory.getProxy().submit("工资流水在此");
ProxyFactory.getProxy().defend();
}
}
-
动态代理(动态生成代理类)
- JDK自带的动态代理
- javaassist字节码操作库实现
- CGLIB
- ASM(底层使用指令，可维护性较差)
-
动态代理相比于静态代理的优点
- 抽象角色中(接口)声明的所以方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法。
-
JDK自带的动态代理
- java.lang.reflect.Proxy
- 作用：动态生成代理类和对象
- java.lang.reflect.InvocationHandler(处理器接口)
- 可以通过invoke方法实现对真实角色的代理访问。
- 每次通过Proxy生成代理类对象时都要指定对应的处理器对象
- java.lang.reflect.Proxy
案例一
Star realStar = new RealStal();
StarHandler handler = new StarHandler(realStar);
Star proxy = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Star.class},handler);
proxy.sing();
package com.bjsxt.proxy.dynamicProxy;
public interface Star {
/**
* 面谈
*/
void confer();
/**
* 签合同
*/
void signContract();
/**
* 订票
*/
void bookTicket();
/**
* 唱歌
*/
void sing();
/**
* 收钱
*/
void collectMoney();
}
package com.bjsxt.proxy.dynamicProxy;
public class RealStar implements Star {
@Override
public void bookTicket() {
System.out.println("RealStar.bookTicket()");
}
@Override
public void collectMoney() {
System.out.println("RealStar.collectMoney()");
}
@Override
public void confer() {
System.out.println("RealStar.confer()");
}
@Override
public void signContract() {
System.out.println("RealStar.signContract()");
}
@Override
public void sing() {
System.out.println("RealStar(周杰伦本人).sing()");
}
}
package com.bjsxt.proxy.dynamicProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class StarHandler implements InvocationHandler {
Star realStar;
public StarHandler(Star realStar) {
super();
this.realStar = realStar;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object object = null;
System.out.println("真正的方法执行前！");
System.out.println("面谈，签合同，预付款，订机票");
if(method.getName().equals("sing")){
object = method.invoke(realStar, args);
}
System.out.println("真正的方法执行后！");
System.out.println("收尾款");
return object;
}
}
package com.bjsxt.proxy.dynamicProxy;
import java.lang.reflect.Proxy;
public class Client {
public static void main(String[] args) {
Star realStar = new RealStar();
StarHandler handler = new StarHandler(realStar);
Star proxy = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),
new Class[]{Star.class}, handler);
proxy.sing();
}
}
案例二
package com.bjsxt.proxy.dynamicProxy1;
//抽象主题
public interface Subject {
void Request();
}
package com.bjsxt.proxy.dynamicProxy1;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
//动态代理
public class DynamicProxy implements InvocationHandler {
private Object obj;
public DynamicProxy(Object obj) {
this.obj=obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
method.invoke(obj, args);
return null;
}
}
package com.bjsxt.proxy.dynamicProxy1;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
public class ProxyTest {
public static void main(String[] args) {
Subject subject = null;
InvocationHandler handler = null;
handler = new DynamicProxy(new RealSubject1());
subject = (Subject) Proxy.newProxyInstance(Subject.class.getClassLoader(), new Class[] {Subject.class}, handler);
subject.Request();
}
}
package com.bjsxt.proxy.dynamicProxy1;
//真实主题1
public class RealSubject1 implements Subject {
@Override
public void Request() {
System.out.println("真实主题1");
}
}
package com.bjsxt.proxy.dynamicProxy1;
//真实主题2
public class RealSubject2 implements Subject {
@Override
public void Request() {
System.out.println("真实主题2");
}
}
-
开发框架中应用场景：
- struts2中拦截器的实现
- 数据库连接池关闭处理
- Hibernate中演示加载的实现
- mybatis中实现拦截器插件
- AspectJ的实现
- Spring中AOP的实现
- 日志拦截
- 声明式事务处理
- web service
- RMI远程方法调用
- …
- 实际上，随便选择一个技术框架都会用到代理模式
-
AOP(Aspect-Oriented Programming，面向切面的编程)
- 它是可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。它是一种新的方法论，它是对传统OOP编程的一种补充。
-
常用术语：
- 切面(Aspect)：其实就是共有功能的实现。
- 通知(Advice)：是切面的具体实现。
- 连接点(Joinpoint)：就是程序在运行过程中能够插入切面的地点。
- 切入点(Pointcut)：用于定义通知应该切入到哪些连接点上。
- 目标对象(Target)：就是那些即将切入切面的对象，也就是那些被通知的对象
- 代理对象(Proxy)：将通知应用到目标对象之后被动态创建的对象。
- 织入(Weaving)：将切面应用到目标对象从而创建一个新的代理对象过程。
-
开源的AOP框架
- AspectJ
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
