结构性模式
核心作用：是从程序的结构上实现松耦合，从而可以扩大整体类的结构，用来解决更大的问题。、
分类：适配器模式，代理模式，桥接模式，装饰模式，组合模式，外观模式，享元模式。
（1）适配器模式
- 什么是适配器模式？
将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以在一起工作。 - 模式中的角色
- 目标接口（Target）：客户所期待的接口。目标可以是具体的或抽象的类，也可以是接口。
- 需要适配的类（Adaptee）：需要适配的类或者适配者类。
- 适配器（Adapter）：通过包装一个需要适配的对象，把原接口转换成目标接口。
例子：如一个键盘是传统的键盘，只有PS/2接口，但是笔记本需要USB接口，此时就需要一个适配器把PS/2接口转换成USB接口。
首先写一个需要被适配的类
package pattern.adapter;
/**
* 被适配的类
* （相当于例子中的PS/2键盘）
*/
public class Adaptee {
public void request(){
System.out.println("可以完成客户请求的需要的功能");
}
}
编写处理请求的接口
package pattern.adapter;
public interface Target {
//用来处理请求
void handleReq();
}
适配器
package pattern.adapter;
/**
* 适配器（对象适配器,使用了组合的方式跟被适配对象整合）
* （相当于USB和PS/2的转换器）
*/
public class Adapter implements Target {
private Adaptee adaptee;
@Override
public void handleReq() {
adaptee.request();
}
public Adapter(Adaptee adaptee) {
this.adaptee = adaptee;
}
}
客户端调用
package pattern.adapter;
/**
* 客户端类
* （相当于例子中的笔记本，只有USB接口）
*/
public class Client {
//调用相当于USB接口
public void test1(Target target){
target.handleReq();
}
public static void main(String[] args) {
//new一个笔记本电脑
Client client=new Client();
//new一个被适配的类
Adaptee adaptee =new Adaptee();
//适配器
Target target=new Adapter(adaptee);
//调用方法
client.test1(target);
}
}
测试结果
可以完成客户请求的需要的功能
（2）代理模式
核心作用
- 通过代理，控制对对象的访问！
- 可以详细控制访问某个（某类）对象的方法，在调用这个方法前做前置处理，调用这个方法后做后置处理。（即：AOP的微观实现！）
应用场景
- 安全代理：屏蔽对真实角色的直接访问。
- 远程代理：通过代理类处理远程方法调用（RMI）。
- 延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象。
比如你要开发一个大文档查看软件，大文档中有大的照片，有可能一个照片有100MB，在打开文件时不可能将所有的照片都显示出来，这样就可以用代理模式，当需要查看图片时，用proxy（代理）来进行大图片的打开。
分类
- 静态代理（静态定义代理类）
- 动态代理（动态生成代理类）
- JDK自带的动态代理
- javaassist字节码操作库实现
- CGLIB
- ASM（底层使用指令，可维护性较差）
静态代理（代理类需要定义）
package pattern.proxy.staticProxy;
public interface Star {
//面谈
void confer();
//签合同
void signContract();
//订票
void bookTicket();
//唱歌
void sing();
//收钱
void collectMoney();
}
真实类
package pattern.proxy.staticProxy;
public class RealStar implements Star {
@Override
public void confer() {
System.out.println("RealStar.confer");
}
@Override
public void signContract() {
System.out.println("RealStar.signContract");
}
@Override
public void bookTicket() {
System.out.println("RealStar.bookTicket");
}
@Override
public void sing() {
System.out.println("RealStar.sing:周杰伦");
}
@Override
public void collectMoney() {
System.out.println("RealStar.collectMoney");
}
}
代理类
package pattern.proxy.staticProxy;
public class ProxyStar implements Star {
private Star star;
public ProxyStar(Star star) {
this.star = star;
}
@Override
public void confer() {
System.out.println("ProxyStar.confer");
}
@Override
public void signContract() {
System.out.println("ProxyStar.signContract");
}
@Override
public void bookTicket() {
System.out.println("ProxyStar.bookTicket");
}
@Override
public void sing() {
star.sing();
}
@Override
public void collectMoney() {
System.out.println("ProxyStar.collectMoney");
}
}
测试
package pattern.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();
}
}
结果
ProxyStar.confer
ProxyStar.signContract
ProxyStar.bookTicket
RealStar.sing:周杰伦
ProxyStar.collectMoney
动态代理（代理类交给工具生成）
**优点：**抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法。
JDK自带的动态代理
- java.lang.reflect.Proxy
作用：动态生成代理类和对象 - java.lang.reflect.InvocationHandler(处理器接口)
可以通过invoke方法实现对真实角色的代理访问。
每次通过Proxy生成代理类对象对象时都要指定对应的处理器对象
定义接口和真实类
package pattern.proxy.dynamicProxy;
public interface Star {
//面谈
void confer();
//签合同
void signContract();
//订票
void bookTicket();
//唱歌
void sing();
//收钱
void collectMoney();
}
package pattern.proxy.dynamicProxy;
public class RealStar implements Star {
@Override
public void confer() {
System.out.println("RealStar.confer");
}
@Override
public void signContract() {
System.out.println("RealStar.signContract");
}
@Override
public void bookTicket() {
System.out.println("RealStar.bookTicket");
}
@Override
public void sing() {
System.out.println("RealStar.sing:周杰伦");
}
@Override
public void collectMoney() {
System.out.println("RealStar.collectMoney");
}
}
使用动态代理
package pattern.proxy.dynamicProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class StarHandler implements InvocationHandler {
Star realStar;
public StarHandler(Star realStar) {
this.realStar = realStar;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("################");
method.invoke(realStar,args);
return null;
}
}
测试
package pattern.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.bookTicket();
proxy.sing();
}
}
结果
################
RealStar.bookTicket
################
RealStar.sing:周杰伦
只要调用代理方法都进到这个里边
所以可以在这里进行判断
package pattern.proxy.dynamicProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class StarHandler implements InvocationHandler {
Star realStar;
public StarHandler(Star realStar) {
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;
}
}
在这里只需要调用唱歌方法，把其他的放到invoke中处理
package pattern.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();
}
}
结果
真正的方法执行前！
面谈，签合同，预付款，订机票
RealStar.sing:周杰伦
真正的方法执行后！
收尾款
5857
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
