设计模式-结构型

结构型

适配器模式

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;
		}
	}
	
}