java设计模式

最新推荐文章于 2024-07-08 16:46:39 发布

qmylzx

最新推荐文章于 2024-07-08 16:46:39 发布

阅读量1k

点赞数

分类专栏： java设计模式

本文链接：https://blog.csdn.net/qmylzx/article/details/82878386

版权

java设计模式专栏收录该内容

2 篇文章 0 订阅

订阅专栏

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

策略模式：定义了算法族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。
PS：即将对象的行为抽象出来成一个接口，用一组类来实现接口的行为，然后在对象类中使用接口来引用行为类。

Duck类

package headfirst.strategy;

public abstract class Duck {
	FlyBehavior flyBehavior;
	QuackBehavior quackBehavior;

	public Duck() {
	}

	public void swim() {
		System.out.println("Duck can swim!");
	}
	
	public void performQuack() {
		quackBehavior.quack();
	}
	
	public void performFly() {
		flyBehavior.fly();;
	}
	
	public void setFlyBehavior(FlyBehavior flyBehavior) {
		this.flyBehavior = flyBehavior;
	}

	public void setQuackBehavior(QuackBehavior quackBehavior) {
		this.quackBehavior = quackBehavior;
	}

}

接口行为

package headfirst.strategy;

public interface QuackBehavior {
	void quack();
}


package headfirst.strategy;

public interface FlyBehavior {
	void fly();
}

接口行为实现

package headfirst.strategy;

public class FlyWithSwing implements FlyBehavior{

	@Override
	public void fly() {
		// TODO Auto-generated method stub
		System.out.println("fly");
	}

}



package headfirst.strategy;

public class Squack implements QuackBehavior{

	@Override
	public void quack() {
		// TODO Auto-generated method stub
		System.out.println("zhi zhi zhi");
	}

}

package headfirst.strategy;

public class Quack implements QuackBehavior{

	@Override
	public void quack() {
		// TODO Auto-generated method stub
		System.out.println("gagaga");
	}

}

实现的鸭子

package headfirst.strategy;
public class WhiteDuck extends Duck{
	public WhiteDuck() {
		flyBehavior = new FlyWithSwing();
		quackBehavior = new Quack();
	}
	
	public static void main(String[] args) {
		Duck model = new WhiteDuck();
		model.performFly();
		model.performQuack();
		model.setQuackBehavior(new MuteQuack());
		model.performQuack();
	}
}

被观察对象 observer
松耦合出版者 +   订阅者
观察者模式：定义了对象之间一对多依赖，这样一来，当一个对象状态改变时，他的所有依赖者都会收到通知并更新。
   PS：出版者发生信息变化的时候会通知所有订阅者，订阅者和第三方类可以退订或者订购出版者的消息。
           Subject接口            Observer接口
       registerObserver();               update();
       removeObserver();               需要保存出版者的引用
       notifyObserver();               方便退订操作
   实现类中有一个List<Observer>
   当信息改变时，循环调用所有Observer
   的update();

java内置的 Observable 类 Observer接口
update(Observable obs,Object arg);
这里可以自定义用obs来get想要的数据
       这里继承后可以设置
       一个changd=false
       当状态改变到一定时
       设置true并调用update

接口可以在Subject中设置一个flag 然后当数据变化到一定变化时再设置为true执行

package headfirst.observer;


public interface Observer {
    void update(double temple,double dryrate);//推数据
    void update(Subject subject,Object arg);//拉数据，可观察者自定义拉所需要的数据
}


package headfirst.observer;

public interface Subject {
    void registerObserver(Observer o);
    void removeObserver(Observer o);
    void notifyObserver();
}

实现类

package headfirst.observer;

import java.util.LinkedList;
import java.util.List;

/**
 * Created by Alen on 2018/9/28.
 */
public class WeatherData implements Subject{
    private double temple;
    private double dryrate;
    private List<Observer> observers ;

    WeatherData(){
        observers = new LinkedList<Observer>();
    }


    public double getTemple() {
        return temple;
    }


    public double getDryrate() {
        return dryrate;
    }

    public void measureChanged(){
        notifyObserver();
    }

    public void setMeasure(double temple,double dryrate){
        this.dryrate = dryrate;
        this.temple = temple;
        measureChanged();
    }

    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
    }

    @Override
    public void removeObserver(Observer o) {
        int i =observers.indexOf(o);
        if(i>=0){
            observers.remove(i);
        }
    }

    @Override
    public void notifyObserver() {
        for (Observer observer : observers) {
            observer.update( temple, dryrate);
        }
    }



}

package headfirst.observer;

/**
 * Created by Alen on 2018/9/28.
 */
public class Display implements Observer {
    Subject subject;
    private double temple;
    private double dryrate;

    Display( Subject subject){
        this.subject=subject;
        subject.registerObserver(this);
    }

    @Override
    public void update(double temple,double dryrate) {
        this.dryrate = dryrate;
        this.temple = temple;
        display();
    }

    public void display(){
        System.out.println("this"+dryrate+","+temple);
    }

    public static void main(String[] args) {
        WeatherData weatherData = new WeatherData();
        Display display= new Display(weatherData);
        weatherData.setMeasure(20,20);
    }

}

利用Java Util包的实现

package headfirst.observer.useutil;

import java.util.Observable;

/**
 * Created by Alen on 2018/9/28.
 */
public class WeatherData extends Observable{
    private double temple;
    private double dryrate;
    WeatherData(){

    }
    public void measureChanged(){
        setChanged();
        notifyObservers();
    }
    public void setMeasure(double temple,double dryrate){
        this.dryrate = dryrate;
        this.temple = temple;
        measureChanged();
    }

    public double getTemple() {
        return temple;
    }

    public double getDryrate() {
        return dryrate;
    }
}

package headfirst.observer.useutil;


import java.util.Observable;
import java.util.Observer;

/**
 * Created by Alen on 2018/9/28.
 */
public class Display implements Observer {
    private double temple;
    private double dryrate;
    Observable observable;
    Display(Observable observable){
        this.observable = observable;
        observable.addObserver(this);
    }
    @Override
    public void update(Observable observable, Object arg) {
        if (observable instanceof Observable){
           WeatherData weatherData = (WeatherData) observable;
            this.dryrate = weatherData.getDryrate();
            this.temple = weatherData.getTemple();
            display();
        }
    }
    public void display(){
        System.out.println("this"+dryrate+","+temple);
    }

    public static void main(String[] args) {
       WeatherData weatherData = new WeatherData();
        Display display = new Display(weatherData);
        weatherData.setMeasure(1,1);
    }
}

装饰者模式：动态地将责任附加到对象上，若需要扩展功能，装饰者提供了比继承更有弹性的替代方案

基础类

package headfirst.decorator;

//饮料类
public abstract class Beverage {
    String description = "Unknown Beverage";
    public  String getDescription(){
        return description;
    }
    public abstract double cost();

}

咖啡类

package headfirst.decorator;

//浓咖啡
public class Espresso extends Beverage {
    public Espresso(){
        description = "Espresso";
    }
    @Override
    public double cost() {
        return 1.99;
    }
}


package headfirst.decorator;

//另外一种饮料
public class HouseBlend extends Beverage {
    public HouseBlend(){
        description = "HouseBlend";
    }
    @Override
    public double cost() {
        return 0.89;
    }
}

装饰器类

package headfirst.decorator;

//调料装饰者
public abstract class CondimentDecorator extends Beverage{
    public abstract String getDescription();
}





package headfirst.decorator;

/**
 * Created by Alen on 2018/9/28.
 */
public class Moka extends CondimentDecorator {
    Beverage beverage ;

    public Moka (Beverage beverage) {
         this.beverage = beverage;
    }

    @Override
    public String getDescription() {
        return beverage.getDescription()+",Moka";
    }

    @Override
    public double cost() {
        return 0.2+beverage.cost();
    }

    public static void main(String[] args) {
        HouseBlend houseBlend = new HouseBlend();
        Moka moka = new Moka(houseBlend);
        System.out.println(moka.getDescription()+""+moka.cost());
        Espresso espresso =new Espresso();
        Moka moka1 = new Moka(espresso );
        System.out.println(moka1.getDescription()+""+moka1.cost());
        //double moka
        Moka moka2 =new Moka(moka1);
        System.out.println(moka2.getDescription()+""+moka2.cost());

    }
}

简单工厂(Simple Factory)又叫做静态工厂方法（Static Factory Method）有一个产品接口没有工厂接口

package com.wenniuwuren.simplefactory;
/**
 * 工厂（Creator）角色 ：简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。
 * 工厂类可以被外界直接调用，创建所需的产品对象。
 *
 */
public class SomethingCreator {
	// 静态工厂   这就是为什么简单工厂又叫静态工厂方法
    public static Tree factory(String fruitType) throws Exception{
        if(fruitType.equals("Lemon")){
            return new LemonTree();
        }else if(fruitType.equals("Apple")){
            return new AppleTree();
        }else{
            throw new Exception("暂时不支持生产该类型产品");
        }
    }
}

工厂方法模式：定义了一个创建对象的接口，但是由子类决定要实例化哪一个类，工厂方法把让类实例化推迟到子类。

抽象工厂模式：提供了一个接口，用于创建相关或依赖对象的家族，而不需要指定具体类

工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例，也就是创建的是一个产品线下的多个产品。

区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。
工厂方法创建 "一种" 产品，他的着重点在于"怎么创建"，也就是说如果你开发，你的大量代码很可能围绕着这种产品的构造，初始化这些细节上面。也因为如此，类似的产品之间有很多可以复用的特征，所以会和模版方法相随。

抽象工厂需要创建一些列产品，着重点在于"创建哪些"产品上，也就是说，如果你开发，你的主要任务是划分不同差异的产品线，并且尽量保持每条产品线接口一致，从而可以从同一个抽象工厂继承。

单例模式：确保一个类只有一个实例，并且提供全局访问点

  //  1.延迟初始化
          private volatile Resource resource;
        public Resource getResource() {
            if (resource == null) {
                synchronized (this) {
                    if (resource == null) {
                        resource = new Resource();
                    }
                }
            }
            return resource;
        }
  //  2.快速初始化
        public static Resource getResource() {//initialized   三个状态 ，其他检测到字段wei
            return InstanceHolder.re;  //第二个，就释放锁，挂起等待唤醒
        }
        private static class InstanceHolder {
            public static Resource re = new Resource(); //会使用 Class对象初始化锁 和 state字段
        } //其中状态有noInitialization  initializing
   // 3.同步初始化，性能差 
        public synchronized Resource getResource(){
            if(null==resource){
                resource = new Resource();
            }
        }

命令模式：将请求封装成对象，以便使用不同的请求，队列或者日志来参数化其他对象。命令模式也支持可撤销的           操作。
       PS：分隔开“发出请求的对象”与“接受和执行这些请求的对象”
   服务员 Command
   takeroder   setCommand
   orderup 客户端
   厨师       execute
   顾客       Receiver

package headfirst.command;

public interface Command {
    public void execute();
    public void undo();
}



package headfirst.command;


public class CommandController {
    Command  oncommand;
    Command offcommand;

    public void setCommand(Command  oncommand,Command offcommand) {
        this.offcommand = offcommand;
        this.oncommand = oncommand;
    }
    public void onButtonWasPressed(){
        oncommand.execute();
    }
    public void offButtonWasPressed(){
        offcommand.execute();
    }
}



package headfirst.command;

public class LigthOnCommand implements Command {
    Light light;
    LigthOnCommand(Light light){
         this.light=light;
    }
    @Override
    public void execute() {
        light.on();
    }

    @Override
    public void undo() {
        light.off();
    }
}

package headfirst.command;

public class Light {
    void on() {
        System.out.println("on");
    }

    void off() {
        System.out.println("off");
    }
}


public class test {
    public static void main(String[] args) {
        CommandController controller = new CommandController();
        LigthOnCommand ligthOnCommand = new LigthOnCommand(new Light());
        controller.setCommand(ligthOnCommand,ligthOnCommand);
        controller.onButtonWasPressed();
    }
}

适配器模式：将一个类的接口转换成客户期望的另外一个接口，适配器让原本接口不兼容的类可以合作无间
对象适配器：通过实现接口，然后使用组合关联。
类适配器：通过继承被适配对象，实现目标接口

// 对象适配器
// 适配器类，直接关联被适配类，同时实现标准接口
class Adapter implements Target{
    // 直接关联被适配类
    private Adaptee adaptee;

    // 可以通过构造函数传入具体需要适配的被适配类对象
    public Adapter (Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    public void request() {
        // 这里是使用委托的方式完成特殊功能
        this.adaptee.specificRequest();
    }
}

// 测试类
public class Client {
    public static void main(String[] args) {
        // 使用普通功能类
        Target concreteTarget = new ConcreteTarget();
        concreteTarget.request();

        // 使用特殊功能类，即适配类，
        // 需要先创建一个被适配类的对象作为参数
        Target adapter = new Adapter(new Adaptee());
        adapter.request();
    }
}

---------------------
类适配器

// 已存在的、具有特殊功能、但不符合我们既有的标准接口的类
class Adaptee {
    public void specificRequest() {
        System.out.println("被适配类 具有特殊功能...");
    }
}

// 目标接口，或称为标准接口
interface Target {
    public void request();
}

// 具体目标类，只提供普通功能
class ConcreteTarget implements Target {
    public void request() {
        System.out.println("普通类 具有普通功能...");
    }
}

// 适配器类，继承了被适配类，同时实现标准接口
class Adapter extends Adaptee implements Target{
    public void request() {
        super.specificRequest();
    }
}

// 测试类
public class Client {
    public static void main(String[] args) {
        // 使用普通功能类
        Target concreteTarget = new ConcreteTarget();//实例化一个普通类
        concreteTarget.request();

        // 使用特殊功能类，即适配类
        Target adapter = new Adapter();
        adapter.request();
    }
}

外观模式：提供了一个统一的接口，用来访问子系统中的一群接口，外观定义了一个高层接口，让子系统更容易使用

class HealthOffice implements Executive{

    @Override
    public void approve() {
        System.out.println("卫生局通过审批");
    }
    
}
class RevenueOffice implements Executive{

    @Override
    public void approve() {
        System.out.println("税务局完成登记，定时回去收税");
    }
    
}
class SaicOffice implements Executive{

    @Override
    public void approve() {
        System.out.println("工商局完成审核，办法营业执照");
    }
    
}

class ApproveFacade {

    public ApproveFacade() {

    }

    public void wholeApprove() {
        new HealthOffice().approve();
        new RevenueOffice().approve();
        new SaicOffice().approve();
    }

}

public class FacadeTest {

    public static void main(String[] args) {
        System.out.println("开始办理行政手续...");

        ApproveFacade af = new ApproveFacade();
        af.wholeApprove();
        
        System.out.println("行政手续终于办完了");
    }

}
//避免了在main中
  //      new HealthOffice().approve();
  //      new RevenueOffice().approve();
    //    new SaicOffice().approve();

模版方法模式：在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中来实现，模版方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。

public abstract CaffeineBeverage{
   void prepare(){ //模版方法
       boilWater();
       brew();
       pourInCup();
       addCondiments();
       hook(); //钩子，子类看情况要不要覆盖实现
   }
   void void boilWater(){
       dosth("");
   }
   void pourInCup(){
       dosth("");
   }
   abstract void brew();//由子类实现
   abstract void addCondiments();//由子类实现

   void hook(){
      //do nothing!!!!
   }
}
钩子:1.可以让子类实现算法中可选的部分
   2.让子类对模版方法中即将发生的方法做出反应

迭代器模式：提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示

组合模式Composite：允许你将对象组合成树形结构来表现“整体-部分”层次结构。组合能够让客户以一种
一致的方式处理个别对象以及对象组合

状态模式:允许对象内部状态改变的时候改变他的行为，对象看起来好像修改了它的类。
       将状态变化委托到具体到状态类（实现state 接口）
       对象内部有所有状态
       包含一个（当前）state保存当前状态
       调用当前对象类到request()方法来调用state.handle();
   interface state{
       CurrentClass class;//处理handle后改变状态使用
       handle();
   }
   1.找出所有状态
   2.创建一个实例持有目前的状态，然后给每个状态定义值
   3.将系统中可以发生的动作整合

package headfirst.state;

public interface State {
    void insertMoney();

    void ejectMoney();

    void trunCrank();

    void dispensed();
}

package headfirst.state;

/**
 * Created by Alen on 2018/10/5.
 */
public class SoldState implements State{
    BookMachine bookMachine;

    public SoldState(BookMachine bookMachine) {
        this.bookMachine = bookMachine;
    }

    @Override
    public void insertMoney() {
        System.out.println("Please wait book out!");
    }

    @Override
    public void ejectMoney() {
        System.out.println("Sorry ,you have trun the Crank ");
    }

    @Override
    public void trunCrank() {
        System.out.println("should not trun again!!!!");

    }

    @Override
    public void dispensed() {
        bookMachine.releaseBook();
        if(bookMachine.getCount()>0){
            bookMachine.setState(bookMachine.getNoMoneyState());
        }else {
            System.out.println("book has sold out!!!!!");
            bookMachine.setState(bookMachine.getSoldOutState());
        }
    }
}



package headfirst.state;

/**
 * Created by Alen on 2018/10/5.
 */
public class WinnerState implements State {
    BookMachine bookMachine;

    public WinnerState(BookMachine bookMachine) {
        this.bookMachine = bookMachine;
    }

    @Override
    public void insertMoney() {
        System.out.println("Please wait book out!");
    }

    @Override
    public void ejectMoney() {
        System.out.println("Sorry ,you have trun the Crank ");
    }

    @Override
    public void trunCrank() {
        System.out.println("should not trun again!!!!");

    }


    @Override
    public void dispensed() {
        System.out.println("you are winner,two book you get!");
        bookMachine.releaseBook();
        if(bookMachine.getCount()==0){
            bookMachine.setState(bookMachine.getSoldOutState());
        }else {
            bookMachine.releaseBook();
            if(bookMachine.getCount()>0){
                bookMachine.setState(bookMachine.getNoMoneyState());
            }else {
                bookMachine.setState(bookMachine.getSoldOutState());
            }
        }
    }
}


package headfirst.state;

/**
 * Created by Alen on 2018/10/5.
 */
public class SoldOutState implements State{
    BookMachine bookMachine;

    public SoldOutState(BookMachine bookMachine) {
        this.bookMachine = bookMachine;
    }
    @Override
    public void dispensed() {
        System.out.println("no dispensed");
    }

    @Override
    public void trunCrank() {
        System.out.println("sold out!!!!");

    }

    @Override
    public void ejectMoney() {
        System.out.println("return your money");
    }

    @Override
    public void insertMoney() {
        System.out.println("sold out!!!!please ejectMoney");
    }
}

package headfirst.state;

/**
 * Created by Alen on 2018/10/5.
 */
public class NoMoneyState implements State{
    BookMachine bookMachine;

    public NoMoneyState(BookMachine bookMachine) {
        this.bookMachine = bookMachine;
    }

    @Override
    public void insertMoney() {
        System.out.println("you are insert money");
        bookMachine.setState(bookMachine.getHasMoneyState());
    }

    @Override
    public void ejectMoney() {
        System.out.println("you are not insert money");

    }

    @Override
    public void trunCrank() {
        System.out.println("no money, insert money and try again!!!");

    }

    @Override
    public void dispensed() {
        System.out.println("you need pay first!!!!");
    }
}

package headfirst.state;

import java.util.Random;

/**
 * Created by Alen on 2018/10/5.
 */
public class HasMoneyState implements State {
    BookMachine bookMachine;
    Random randomWinner = new Random(System.currentTimeMillis());

    public HasMoneyState(BookMachine bookMachine) {
        this.bookMachine = bookMachine;
    }

    @Override
    public void insertMoney() {
        System.out.println("Had money!no need insert again!!!");
    }

    @Override
    public void ejectMoney() {
        System.out.println("return your money!!!");
        bookMachine.setState(bookMachine.getNoMoneyState());
    }

    @Override
    public void trunCrank() {
        System.out.println("you turned....");
        int winner = randomWinner.nextInt(10);
        if ((winner == 0 )&& bookMachine.getCount() > 1) {
            bookMachine.setState(bookMachine.getWinnerState());
        } else {
            bookMachine.setState(bookMachine.getSoldState());
        }
    }

    @Override
    public void dispensed() {
        System.out.println("no gumball dispensed");
    }
}

package headfirst.state;

/**
 * Created by Alen on 2018/10/5.
 */
public class BookMachine {
    State hasMoneyState;
    State noMoneyState;
    State soldOutState;
    State soldState;
    State winnerState;
    int bookCount = 0;
    State currentState;

    public BookMachine(int count) {
        this.bookCount = count;
        hasMoneyState = new HasMoneyState(this);
        noMoneyState = new NoMoneyState(this);
        soldOutState = new SoldOutState(this);
        soldState = new SoldState(this);
        winnerState =new WinnerState(this);
        if (count > 0) {
            currentState = noMoneyState;
        }
    }

    public void insertMoney() {
        currentState.insertMoney();
    }

    public void ejectMoney() {
        currentState.ejectMoney();
    }

    public void trunCrank() {
        currentState.trunCrank();
        currentState.dispensed();
    }

    void releaseBook() {
        System.out.println("a gumball come rolling out the slot");
        if (bookCount != 0) {
            bookCount -= 1;
        }
    }

    public int getCount() {
        return bookCount;
    }

    public void setState(State state) {
        currentState = state;
    }
    public State getState(){
        return currentState;
    }

    public State getHasMoneyState() {
        return hasMoneyState;
    }

    public State getWinnerState() {
        return winnerState;
    }

    public State getNoMoneyState() {
        return noMoneyState;
    }

    public State getSoldOutState() {
        return soldOutState;
    }

    public State getSoldState() {
        return soldState;
    }

    public State getCurrentState() {
        return currentState;
    }
}



    public static void main(String[] args) {
        BookMachine bookMachine = new BookMachine(10);
        bookMachine.trunCrank();
        System.out.println("==========================="+bookMachine.getCount());
        bookMachine.insertMoney();
        bookMachine.trunCrank();
        System.out.println("==========================="+bookMachine.getCount());
        bookMachine.insertMoney();
        bookMachine.trunCrank();


    }

代理模式:为另外一个对象提供一个替身或则占位符以控制对这个对象对访问

package headfirst.proxy;


public interface BuyHouse {
    void buy();
}


package headfirst.proxy;


public class BuyHouseImp implements BuyHouse {
    @Override
    public void buy() {
        System.out.println("buy");
    }
}

1.静态代理

public class BuyHouseProxy implements BuyHouse {

    private BuyHouse buyHouse;

    public BuyHouseProxy(BuyHouse buyHouse) {
        this.buyHouse = buyHouse;
    }

    @Override
    public void buyHosue() {
        System.out.println("买房前准备");
        buyHouse.buyHosue();
        System.out.println("买房后装修");

    }
}

2.动态代理

package headfirst.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;


public class DynamicProxyHandler implements InvocationHandler {
    private Object object;

    public DynamicProxyHandler(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before");
        Object result = method.invoke(object, args);
        System.out.println("after");
        return result;
    }

        public static void main(String[] args) {
        BuyHouse buyHouse = new BuyHouseImp();
        BuyHouse buyHouseProxy =       (BuyHouse)Proxy.newProxyInstance(BuyHouse.class.getClassLoader(),new Class[]{BuyHouse.class},new DynamicProxyHandler(buyHouse));
        buyHouseProxy.buy();
    }
}

3.CGLIB代理

package headfirst.proxy;

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 Object getInstance(Object target){
        this.target = target;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(this.target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }

    public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("买房前准备");
        Object result = methodProxy.invokeSuper(object, args);
//      Object result = methodProxy.invoke(object, args);//error stack overflow!!!
        System.out.println("买房后装修");
        return result;
    }

    public static void main(String[] args) {
        BuyHouse buyHouse = new BuyHouseImp();
        CGLibProxy cglibProxy = new CGLibProxy();
        BuyHouse buyHouseCglibProxy = (BuyHouse)cglibProxy.getInstance(buyHouse);
        buyHouseCglibProxy.buy();
    }

}

其中cglib代理与JDK中的代理比较:
JDK动态代理: 只能代理实现了接口的类 没有实现接口的类不能实现JDK动态代理。
Cglib代理: 针对类来实现代理,对指定目标产生一个子类通过方法拦截技术拦截所有父类方法的调用。

CGLib不能对声明为final的方法进行代理

qmylzx

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java设计模式

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。策略模式：定义了算法族，分别封装起来，让他们之间可以互相替换，此...
复制链接

扫一扫

专栏目录