设计模式-结构型

╰+攻爆jí腚メ 2021-10-06 03:14 310阅读 0赞

### 设计模式-结构型 ###

*   *  结构型
     *   *  适配器模式
         *  装饰器模式
         *  代理模式
         *  外观模式
         *  桥接模式
         *  组合模式
         *  享元模式

## 结构型 ##

### 适配器模式 ###

package com.plxc.pattern.structure;
    
    /**
     * 结构型-适配器模式
     * 在原来的类、接口、对象上提供新功能
     * 
     * @author vander
     *
     */
    public class BAdapter {
    	public static void main(String[] args) {
    		//类适配
    		ClassAdapter classAdapter = new ClassAdapter();
    		classAdapter.eat();
    		classAdapter.work();
    		//对象适配
    		ObjectAdapter objectAdapter = new ObjectAdapter(new OldClass());
    		objectAdapter.work();
    		//接口适配
    		InterfaceHandler interfaceHandler = new InterfaceHandler();
    		interfaceHandler.eat();
    		interfaceHandler.work();
    	}
    }
    
    interface AddWork{
    	void work();
    }
    
    class OldClass{
    	public void eat(){
    		System.err.println("吃...");
    	}
    }
    
    class ClassAdapter extends OldClass implements AddWork{
    	@Override
    	public void work() {
    		System.err.println("工作...");
    	}
    }
    
    class ObjectAdapter implements AddWork{
    	OldClass oldObject;
    	public ObjectAdapter(OldClass oldObject) {
    		this.oldObject = oldObject;
    	}
    	@Override
    	public void work() {
    		oldObject.eat();
    		System.err.println("工作...");
    	}
    }
    
    interface InterfaceAdapter extends AddWork{
    	void eat();
    }
    
    class InterfaceHandler implements InterfaceAdapter{
    	@Override
    	public void work() {
    		System.err.println("工作...");
    	}
    	@Override
    	public void eat() {
    		System.err.println("吃...");
    	}
    }

### 装饰器模式 ###

package com.plxc.pattern.structure;
    
    /**
     * 结构型-装饰器模式
     * 向一个现有的对象添加新的功能，同时又不改变其结构
     * 
     * @author vander
     *
     */
    public class BDecorator {
    	public static void main(String[] args) {
    		DogDecorator dogDecorator = new DogDecorator(new Dog());
    		dogDecorator.eat();
    		dogDecorator.call();
    	}
    }
    
    interface Animal{
    	void eat();
    }
    
    class Dog implements Animal{
    	@Override
    	public void eat() {
    		System.err.println("狗吃饭...");
    	}
    }
    
    abstract class AnimalDecorator implements Animal{
    	Animal Animal;
    	public AnimalDecorator(Animal animal) {
    		Animal = animal;
    	}
    	@Override
    	public void eat() {
    		Animal.eat();
    	}
    }
    
    class DogDecorator extends AnimalDecorator{
    	public DogDecorator(Animal animal) {
    		super(animal);
    	}
    	public void call() {
    		System.err.println("汪...");
    	}
    	
    }

### 代理模式 ###

package com.plxc.pattern.structure;
    
    /**
     * 结构型-代理模式
     * 一个类代表另一个类的功能
     * 
     * @author vander
     *
     */
    public class BProxy {
    	public static void main(String[] args) {
    		Proxy proxy = new Proxy();
    		proxy.show();
    	}
    }
    
    interface Work{
    	void show();
    }
    
    class Star implements Work{
    	@Override
    	public void show() {
    		System.err.println("明星表演...");		
    	}
    }
    
    class Proxy implements Work{
    	Star star = new Star();
    	@Override
    	public void show() {
    		before();
    		star.show();
    		after();
    	}
    	private void before() {
    		System.err.println("签约...");
    	}
    	private void after() {
    		System.err.println("收款...");
    	}
    }

JDK自带的动态代理

#java.lang.reflect.Proxy:生成动态代理类和对象；
    #java.lang.reflect.InvocationHandler（处理器接口）：可以通过invoke方法实现
    public interface Subject {
        public String work();
    }
    public class RealSubject implements Subject{
        @Override
        public String work() {
            System.out.println("work...");
            return "work";
        }
    }
    
    #处理器对象
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;    
    public class MyInvocationHandler implements InvocationHandler {
        /**
         * 因为需要处理真实角色，所以要把真实角色传进来
         */
        Subject realSubject ;
    
        public MyInvocationHandler(Subject realSubject) {
            this.realSubject = realSubject;
        }
    
        /**
         *
         * @param proxy    代理类
         * @param method    正在调用的方法
         * @param args      方法的参数
         * @return
         * @throws Throwable
         */
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("调用代理类...");
            if(method.getName().equals("work")){
                String string = (String) method.invoke(realSubject,args) ;
                System.out.println("调用的是work的方法");
                return invoke ;
            }
        }
    }
    public class Client {
        public static void main(String[] args) {
            //真实对象
            Subject realSubject =  new RealSubject();
            MyInvocationHandler myInvocationHandler = new MyInvocationHandler(realSubject);
            //代理对象
            Subject proxyClass = (Subject) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Subject.class}, myInvocationHandler);
            //调用方法
            proxyClass.work();
        }
    }

Cglib 动态代理是针对代理的类，服务代理被代理类中的private和final修饰的方法

public class Engineer {
        // 可以被代理
        public void eat() {
            System.out.println("工程师正在吃饭");
        }
    }
    
    import net.sf.cglib.proxy.Enhancer;
    import net.sf.cglib.proxy.MethodInterceptor;
    import net.sf.cglib.proxy.MethodProxy;
    import java.lang.reflect.Method;
    
    public class CglibProxy implements MethodInterceptor {
        private Object target;
    
        public CglibProxy(Object target) {
            this.target = target;
        }
    
        @Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
            System.out.println("###   before invocation");
            Object result = method.invoke(target, objects);
            System.out.println("###   end invocation");
            return result;
        }
    
        public static Object getProxy(Object target) {
            Enhancer enhancer = new Enhancer();
            // 设置需要代理的对象
            enhancer.setSuperclass(target.getClass());
            // 设置代理人
            enhancer.setCallback(new CglibProxy(target));
            return enhancer.create();
        }
    }
    
    import java.lang.reflect.Method;
    import java.util.Arrays;
    
    public class CglibMainTest {
        public static void main(String[] args) {
            // 生成 Cglib 代理类
            Engineer engineerProxy = (Engineer) CglibProxy.getProxy(new Engineer());
            // 调用相关方法
            engineerProxy.eat();
        }
    }

### 外观模式 ###

package com.plxc.pattern.structure;
    
    /**
     * 结构型-外观模式
     * 隐藏系统的复杂性，并向客户端提供了一个客户端可以访问系统的接口
     * 
     * @author vander
     *
     */
    public class BFacade {
    	public static void main(String[] args) {
    		Facade facade = new Facade();
    		facade.eat();
    	}
    }
    
    class Cat implements Animal{
    	@Override
    	public void eat() {
    		System.err.println("猫吃饭...");
    	}
    }
    
    class Facade implements Animal{
    	Cat cat = new Cat();
    	Dog dog = new Dog();
    	@Override
    	public void eat() {
    		cat.eat();
    		dog.eat();
    	}
    }

### 桥接模式 ###

package com.plxc.pattern.structure;
    
    
    /**
     * 结构型-桥接模式
     * 将抽象部分与实现部分分离
     * 
     * @author vander
     *
     */
    public class BBridge {
    	public static void main(String[] args) {
    		Opt opt = new Opt(new Imp(),"...");
    		opt.other();
    	}
    }
    
    interface Implements{
    	void work(String token);
    }
    
    class Imp implements Implements{
    	@Override
    	public void work(String token) {
    		System.err.println(token);
    	}
    }
    
    abstract class Abstract{
    	protected Implements implement;
    	protected Abstract(Implements implement) {
    		this.implement = implement;
    	}
    	abstract void other();
    }
    
    class Opt extends Abstract{
    	private String name;
    	Opt(Implements implement,String name) {
    		super(implement);
    		this.name = name;
    	}
    	@Override
    	void other() {
    		implement.work(name);
    	}
    }

### 组合模式 ###

package com.plxc.pattern.structure;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * 结构型-组合模式
     * 部分整体模式，依据树形结构来组合对象
     * 
     * @author vander
     *
     */
    public class BComposite {
    	public static void main(String[] args) {
    		Node cat = new Node("猫...");
    		Node dog = new Node("狗...");
    		Node animal = new Node("动物...");
    		animal.add(cat);
    		animal.add(dog);
    		System.err.println(animal);
    	}
    }
    
    class Node{
    	private String name;
    	private List<Node> nodes;
    	public Node(String name) {
    		super();
    		this.name = name;
    		nodes = new ArrayList<Node>();
    	}
    	public void add(Node node) {
    		nodes.add(node);
    	}
    	public void remove(Node node) {
    		nodes.remove(node);
    	}
    	public List<Node> getNodes(){
    		return nodes;
    	} 
    	@Override
    	public String toString() {
    		return "Node [name=" + name + ", nodes=" + nodes + "]";
    	}
    }

### 享元模式 ###

package com.plxc.pattern.structure;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * 结构型-享元模式
     * 减少创建对象的数量，以减少内存占用和提高性能
     * @author vander
     *
     */
    public class BFlyweight {
    	public static void main(String[] args) {
    		FlyweightFactory flyweightFactory = new FlyweightFactory();
    		flyweightFactory.getFlyweight("a");
    		flyweightFactory.getFlyweight("b");
    		flyweightFactory.getFlyweight("c");
    		
    		Flyweight flyweight = flyweightFactory.getFlyweight("a");
    		System.err.println(flyweight);
    	}
    }
    
    class Flyweight{
    	private String name;
    	public Flyweight(String name) {
    		this.name = name;
    	}
    	@Override
    	public String toString() {
    		return "Flyweight [name=" + name + "]";
    	}
    	
    }
    
    class FlyweightFactory{
    	private Map<String, Flyweight> data;
    	public FlyweightFactory() {
    		data = new HashMap<String, Flyweight>();
    	}
    	public Flyweight getFlyweight(String name) {
    		if(data.containsKey(name)) {
    			return data.get(name);
    		}else {
    			Flyweight flyweight = new Flyweight(name);
    			data.put(name, flyweight);
    			return flyweight;
    		}
    	}
    	
    }