模板方法模式
到这里我们就开始学习行为型模式了，先来看看行为型模式的介绍吧
行为型模式分为类行为模式和对象行为模式，前者采用继承机制，后者采用组合或者聚合方式，后者的灵活性比前者高
模板方法模式介绍
我们先来学习模板方法模式，先来看看其定义和结构
照样是通过一个例子来加深我们的理解，先来看看例子的需求和类图
案例实现
首先我们创建抽象类，抽象类中应该要有固定的模板方法，这个方法对于每一个人来说都是一样的，不允许子类修改该方法，我们可以给其加入final关键字，所以我们的cookProcess方法才会这样构造
然后我们定义每一个具体要执行的方法，一样的方法我们直接写好，不一样的方法要有子类进行具体实现，我们就定义为抽象方法即可
public abstract class AbstractClass {
//模板方法定义
public final void cookProcess() {
pourOil();
heatOil();
pourVegetable();
pourSauce();
fry();
}
public void pourOil() {
System.out.println("倒油");
}
//第二步：热油是一样的，所以直接实现
public void heatOil() {
System.out.println("热油");
}
//第三步：倒蔬菜是不一样的
public abstract void pourVegetable();
//第四步：倒调味料是不一样
public abstract void pourSauce();
//第五步：翻炒是一样的，所以直接实现
public void fry() {
System.out.println("炒菜ing...");
}
}
然后我们需要定义具体的子类，该子类当然需要实现其抽象方法，我们这里定义了两个子类，代码都大差不差，所以我们只展示其中一个
public class ConcreteClass_BaoCai extends AbstractClass{
@Override
public void pourVegetable() {
System.out.println("蔬菜是包菜，下锅");
}
@Override
public void pourSauce() {
System.out.println("酱料是辣椒，下锅");
}
}
然后我们在测试中写入代码如下，我们这里创建具体的子类，然后直接调用其对应的方法即可
public class Client {
public static void main(String[] args) {
//炒包菜
//创建对象
ConcreteClass_BaoCai baoCai = new ConcreteClass_BaoCai();
//调用炒菜的功能
baoCai.cookProcess();
}
}
然后我们来看看其优缺点和适用场景
JDK源码解析
策略模式
现在我们来学习策略模式，先来看看策略模式的概述
简而言之是，我们可以选择的策略可以有很多，但是我们最终的目的总是一样的
策略模式介绍
同样我们是用一个案例来加深我们的理解，来看看案例需求和类图
案例实现
首先我们创建抽象策略内，内部存放对应的抽象策略方法
public interface Strategy {
void show();
}
然后创建具体的策略类，当然要实现我们的具体策略
public class StrategyA implements Strategy{
@Override
public void show() {
System.out.println("买一送一");
}
}
然后是我们的环境对象，其内部应该聚合策略类对象
public class SalesMan {
//聚合策略类对象
private Strategy strategy;
public SalesMan(Strategy strategy) {
this.strategy = strategy;
}
//由促销员展示促销活动给用户
public void salesManShow() {
strategy.show();
}
public void setStrategy(Strategy strategy) {
this.strategy = strategy;
}
}
接着我们在对应的测试类中写入代码如下，可以得到我们想要的结果，能够正确调用不同的策略
public class Client {
public static void main(String[] args) {
//春节来了，使用策略1
SalesMan salesMan = new SalesMan(new StrategyA());
salesMan.salesManShow();
salesMan.setStrategy(new StrategyB());
salesMan.salesManShow();
salesMan.setStrategy(new StrategyC());
salesMan.salesManShow();
}
}
然后我们来看看策略模式的优缺点和使用场景
JDK源码解析
直接记忆重点，我们的Arrays.sort方法使用了策略模式即可
命令模式
现在我们来学习命令模式，先来看看下面的案例
在我们这里有服务员、订单、厨师对象，服务员要将订单提供给厨师，一般我们会让服务员类聚合厨师类，这样服务员就可以往对应的厨师提供订单，但是我们的厨师是有可能会更换的，如果我们更换厨师，就要修改服务员的源代码，不符合开闭原则
命令模式介绍
此时我们就可以使用命令模式，将一个请求封装为一个对象，服务员通过该对象来联系厨师，这样就实现了解耦合
接着我们来看看命令模式里具有的结构
接着我们将上面的案例用代码实现，在上面的案例中，如果用命令模式实现，那么服务员就是调用者角色、厨师就是接收者角色，而订单则是命令类角色，来看看其类图
首先我们创建订单类，要发送请求当然需要一个订单类，我们这里提供餐桌号码的属性，所用户所辖的餐品和份数则使用Map集合来存储，我们最后提供一个设置食物的方法，这个方法就类似于往订单中写入顾客要的数据，要求提供事物名字和数量，然后我们将其设置到Map集合中
案例实现
public class Order {
//餐桌号码
private int diningTable;
//所下的餐品及份数
private Map<String,Integer> foodDir = new HashMap<>();
public int getDiningTable() {
return diningTable;
}
public void setDiningTable(int diningTable) {
this.diningTable = diningTable;
}
public Map<String, Integer> getFoodDir() {
return foodDir;
}
public void setFood(String name,int num) {
foodDir.put(name,num);
}
}
然后我们当然要创建厨师对象，厨师对象只有一个执行做菜的方法，需要传入对应的名字和份数
public class SeniorChef {
public void makeFood(String name,int num) {
System.out.println(num + "份" + name);
}
}
接着我们设置抽象命令类，只是一个接口
//抽象命令类
public interface Command {
void execute();
}
接着我们写入具体命令类，具体命令类中要实现我们的抽象命令类，然后其下应该要持有接收者对象，也就是厨师对象，以及被接受的对象，也就是订单类，其是请求的根本，提供对有的构造方法，然后重写发送请求的方法
这里我们发送请求的方法就是遍历订单中的Map集合，拿到所有的内容之后调用厨师的做菜方法做菜就完了
//具体命令类
public class OrderCommand implements Command{
//持有接收者对象
private SeniorChef receiver;
private Order order;
public OrderCommand(SeniorChef receiver, Order order) {
this.receiver = receiver;
this.order = order;
}
@Override
public void execute() {
System.out.println(order.getDiningTable()+"桌的订单：");
Map<String, Integer> foodDir = order.getFoodDir();
//遍历map集合
Set<String> set = foodDir.keySet();
for (String foodName : set) {
receiver.makeFood(foodName,foodDir.get(foodName));
}
System.out.println(order.getDiningTable()+"桌的饭菜准备完毕");
}
}
最后我们要定义请求者对象，也就是服务员，服务员可以拥有多个订单，所以拥有List属性，提供设置新订单的方法，这是当然，服务员当然要可以接受订单，然后提供发起命令的方法，如果命令没有问题，就调用请求对象中的发送请求方法，其会调动厨师的做菜方法来做订单中对应的菜
public class Waiter {
//持有多个命令对象
private List<Command> commands = new ArrayList<>();
public void setCommand(Command cmd){
//将cmd对象存储到list集合中
commands.add(cmd);
}
//发起命令的功能
public void orderUp() {
System.out.println("服务员对厨师说订单来了");
for (Command command : commands) {
if(command!=null){
command.execute();
}
}
}
}
最后我们在测试类中写入代码如下，我们这里首先设置两个订单对象，然后创建一个厨师对象和两个命令对象，命令对象需要厨师对象和订单对象，我们这里相当于是让两个命令对象将厨师和对应的命令绑定起来，然后将这两个命令对象设置到服务员对象中，接着让服务员发起命令，即可让服务员发起所有的命令请求，令其正确执行
public class Client {
public static void main(String[] args) {
//创建第一个订单对象
Order order = new Order();
order.setDiningTable(1);
order.setFood("西红柿鸡蛋面",1);
order.setFood("小杯可乐",2);
//创建第二个订单对象
Order order2 = new Order();
order2.setDiningTable(2);
order2.setFood("尖椒肉丝盖饭",1);
order2.setFood("小杯雪碧",2);
//创建厨师对象
SeniorChef receiver = new SeniorChef();
//创建命令对象
OrderCommand cmd1 = new OrderCommand(receiver,order);
OrderCommand cmd2 = new OrderCommand(receiver,order2);
//创建调用者（服务员对象）
Waiter waiter = new Waiter();
waiter.setCommand(cmd1);
waiter.setCommand(cmd2);
//让服务员发起命令
waiter.orderUp();
}
}
最后我们来看看命令模式的优缺点和使用场景
JDK源码解析
JDK中的Runable就是一个典型的命令模式，Thread是调用者，而start则是我们要执行的请求命令，接收者是有我们程序员自己定义的一个全新的类
责任链模式
现在我们来学习责任链模式，先来看看我们的现实生活中的情况
接着我们来看看定义和结构
责任链模式介绍
我们现在来讲解一个案例来加深我们的理解，先来看看案例需求和类图
首先我们要创建的当然是请假条类，没有请假条那怎么发送请求？这里进行基本的构造，提供了对应的构造方法和setandget方法
案例实现
//请假条类
public class LeaveRequest {
//姓名
private String name;
//请假天数
private int num;
//请假内容
private String content;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public LeaveRequest(String name, int num, String content) {
this.name = name;
this.num = num;
this.content = content;
}
}
然后创建抽象处理者类，我们这里提供三个常量用于设置后续不同组员能处理的请假时长，之所以设置常量，是因为后续我们可能会改动他们的权限，此时使用常量我们就可以轻易尽量减少源代码的多次改动
然后我们其中还要聚合另外一个Handler对象，这就意味着我们的一个组长可能有上一级的领导，我们提供对应的构造方法，再提供一个提交请假条的方法，提供请假条的方法先判断当前组长能否成功处理，若能则进行处理，不能则继续提交给上一级
最后还有一个各级领导处理请假条的方法，这个方法由于每个不同级别的领导处理的权限不同，因此设置为抽象方法
public abstract class Handler {
protected final static int NUM_ONE = 1;
protected final static int NUM_THREE = 3;
protected final static int NUM_SEVEN = 7;
//该领导处理的请求天数区间
private int numStart;
private int numEnd;
//声明后继者(声明上级领导)
private Handler nextHandler;
public Handler(int numStart) {
this.numStart = numStart;
}
public Handler(int numStart, int numEnd) {
this.numStart = numStart;
this.numEnd = numEnd;
}
//设置上级领导对象
public void setNextHandler(Handler nextHandler) {
this.nextHandler = nextHandler;
}
//各级领导处理请假条的方法
protected abstract void handleLeave(LeaveRequest leave);
//提交请假条
public void submit(LeaveRequest leave) {
if(this.nextHandler != null && leave.getNum() > this.numEnd){
//提交给上级领导进行审批
this.nextHandler.submit(leave);
}else {
//该领导进行审批
this.handleLeave(leave);
System.out.println("流程结束!");
}
}
}
然后我们创建具体的处理者类，分别是小组长，主管和总经理类，他们都要实现抽象处理者类，其对应的构造方法则传入我们想要设置的能够处理的请假时长，重写的方法则是固定的处理请假的方法
//小组长类，具体的处理者
public class GroupLeader extends Handler{
public GroupLeader() {
super(0,Handler.NUM_ONE);
}
@Override
protected void handleLeave(LeaveRequest leave) {
System.out.println(leave.getName()+"请假"+leave.getNum()+"day,"+leave.getContent()+"。");
System.out.println("小组长审批通过");
}
}
最后我们在客户端中写入如下代码，我们这里先创建请假对象，然后创建各个领导对象，设置对应的领导间具有的层级关系，最后再先由小组长对象提交请假申请，最后可以得到我们想要的结果
public class Client {
public static void main(String[] args) {
//创建一个请假条对象
LeaveRequest leave = new LeaveRequest("小明",1,"身体不适");
//创建各级领导对象
GroupLeader groupLeader = new GroupLeader();
Manager manager = new Manager();
GeneralManager generalManager = new GeneralManager();
//设置处理者链
groupLeader.setNextHandler(manager);
manager.setNextHandler(generalManager);
//小明提交请假申请
groupLeader.submit(leave);
}
}
最后我们来看看其优缺点
JDK源码解析
上面的源码是我们经过处理之后的简单版本的，很好理解我就不多提了，我们记住，FilterChain是职责链（过滤器）模式的典型应用就行了
状态模式
现在我们来学习状态模式，这次跟以往有些不一样，我们先来构造一个案例，再来分析下其缺点
先来看看该例子的需求和类图
首先我们定义对应的接口类然后定义对应的电梯状态的常量，我们这里之所以定义一个接口，是为了能够让以后的类都可以被我们赋予这个状态（如果有这个业务需求的话）
public interface ILift {
//定义四个电梯状态的常量
int OPENING_STATE = 1;
int CLOSING_STATE = 2;
int RUNNING_STATE = 3;
int STOPPING_STATE = 4;
//设置电梯状态的功能
void setState(int state);
//电梯操作功能
void open();
void close();
void run();
void stop();
}
然后我们创建其具体的实现类，其下有对应的属性变量用于记录状态，然后重写了设置状态的方法，接着我们实现其四个功能，每个功能中我们都是用switch方法进行判断，只有其处于对应的状态中我们才执行对应的方法，否则就是直接跳出
public class Lift implements ILift{
//声明一个变量记录当前电梯状态
private int state;
@Override
public void setState(int state) {
this.state=state;
}
//执行开门动作
@Override
public void open() {
switch (this.state) {
case OPENING_STATE://门已经开了，不能再开门了
//do nothing
break;
case CLOSING_STATE://关门状态，门打开:
System.out.println("电梯打开了...");
this.setState(OPENING_STATE);
break;
case RUNNING_STATE:
//do nothing 运行时电梯不能开门
break;
case STOPPING_STATE:
System.out.println("电梯开了...");//电梯停了，可以开门了
this.setState(OPENING_STATE);
break;
}
}
@Override
public void close() {
switch (this.state) {
case OPENING_STATE:
System.out.println("电梯关门了。。。");//只有开门状态可以关闭电梯门，可以对应电梯状态表来看
this.setState(CLOSING_STATE);//关门之后电梯就是关闭状态了
break;
case CLOSING_STATE:
//do nothing //已经是关门状态，不能关门
break;
case RUNNING_STATE:
//do nothing //运行时电梯门是关着的，不能关门
break;
case STOPPING_STATE:
//do nothing //停止时电梯也是关着的，不能关门
break;
}
}
@Override
public void run() {
switch (this.state) {
case OPENING_STATE://电梯不能开着门就走
//do nothing
break;
case CLOSING_STATE://门关了，可以运行了
System.out.println("电梯开始运行了。。。");
this.setState(RUNNING_STATE);//现在是运行状态
break;
case RUNNING_STATE:
//do nothing 已经是运行状态了
break;
case STOPPING_STATE:
System.out.println("电梯开始运行了。。。");
this.setState(RUNNING_STATE);
break;
}
}
@Override
public void stop() {
switch (this.state) {
case OPENING_STATE: //开门的电梯已经是是停止的了(正常情况下)
//do nothing
break;
case CLOSING_STATE://关门时才可以停止
System.out.println("电梯停止了。。。");
this.setState(STOPPING_STATE);
break;
case RUNNING_STATE://运行时当然可以停止了
System.out.println("电梯停止了。。。");
this.setState(STOPPING_STATE);
break;
case STOPPING_STATE:
//do nothing
break;
}
}
}
然后我们在客户端类写入代码如下，能够正确得到我们想要的结果，电梯的对应方法只有在电梯处于对应状态时才可以执行
public class Client {
public static void main(String[] args) {
//创建电梯对象
Lift lift = new Lift();
//设置当前电梯的状态
lift.setState(ILift.RUNNING_STATE);
//打开
lift.open();
lift.close();
lift.run();
lift.stop();
}
}
那么我们上面的程序存在什么问题呢？
我们为了解决这个问题，就可以使用状态模式，先来看看状态模式的定义和结构
状态模式介绍
接着我们就要使用状态模式来改善我们之前的案例，先来看看改进之后的类图
那么首先我们要创建抽象的接口类，该类封装了我们类中拥有的方法以及我们的环境类，可以看到我们这个抽象类聚合了环境变量的属性，然后我们拥有电梯开启关闭运行停止的四个方法（环境类我们下面会创建）
案例改进
public abstract class LiftState {
//声明环境变量类
protected Context context;
public void setContext(Context context){
this.context = context;
}
//电梯开启
public abstract void open();
//电梯关闭
public abstract void close();
//电梯运行
public abstract void run();
//电梯停止
public abstract void stop();
}
接着我们来实现我们的环境类，我们的环境类中组合了四个状态类（这四个类后面会实现），都是作为常量存在，同时其自身还聚合了电梯类，其下提供的设置类中不但会聚合当前的电梯类，还会聚合电梯类中的当前类（也就是环境类）
对应的四个方法则是直接调用我们组合的类中的对应方法
public class Context {
//定义对应状态对象的常量
public final static OpeningState OPENING_STATE = new OpeningState();
public final static ClosingState CLOSING_STATE = new ClosingState();
public final static RunningState RUNNING_STATE = new RunningState();
public final static StoppingState STOPPING_STATE = new StoppingState();
//定义一个当前电梯状态变量
private LiftState liftState;
public LiftState getLiftState() {
return liftState;
}
//设置当前状态对象
public void setLiftState(LiftState liftState) {
this.liftState = liftState;
//设置当前状态对象中的Context对象
this.liftState.setContext(this);
}
public void open() {
this.liftState.open();
}
public void close() {
this.liftState.close();
}
public void run() {
this.liftState.run();
}
public void stop() {
this.liftState.stop();
}
}
然后我们再来创建对应的四个状态类，其都应继承我们的抽象功能类，首先是开启状态的类
public class OpeningState extends LiftState{
//开启当然可以关闭了，我就想测试一下电梯门开关功能
@Override
public void open() {
System.out.println("电梯门开启...");
}
@Override
public void close() {
//状态修改
super.context.setLiftState(Context.CLOSING_STATE);
//动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
super.context.getLiftState().close();
}
//电梯门不能开着就跑，这里什么也不做
@Override
public void run() {
//do nothing
}
//开门状态已经是停止的了
@Override
public void stop() {
//do nothing
}
}
然后是关闭状态的类
public class ClosingState extends LiftState{
@Override
//电梯门关闭，这是关闭状态要实现的动作
public void close() {
System.out.println("电梯门关闭...");
}
//电梯门关了再打开，逗你玩呢，那这个允许呀
@Override
public void open() {
super.context.setLiftState(Context.OPENING_STATE);
super.context.open();
}
//电梯门关了就跑，这是再正常不过了
@Override
public void run() {
super.context.setLiftState(Context.RUNNING_STATE);
super.context.run();
}
//电梯门关着，我就不按楼层
@Override
public void stop() {
super.context.setLiftState(Context.STOPPING_STATE);
super.context.stop();
}
}
接着是运行状态的类
public class RunningState extends LiftState{
//运行的时候开电梯门？你疯了！电梯不会给你开的
@Override
public void open() {
//do nothing
}
//电梯门关闭？这是肯定了
@Override
public void close() {//虽然可以关门，但这个动作不归我执行
//do nothing
}
//这是在运行状态下要实现的方法
@Override
public void run() {
System.out.println("电梯正在运行...");
}
//这个事绝对是合理的，光运行不停止还有谁敢做这个电梯？！估计只有上帝了
@Override
public void stop() {
super.context.setLiftState(Context.STOPPING_STATE);
super.context.stop();
}
}
最后是停止状态的类
public class StoppingState extends LiftState{
//停止状态，开门，那是要的！
@Override
public void open() {
//状态修改
super.context.setLiftState(Context.OPENING_STATE);
//动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
super.context.getLiftState().open();
}
@Override
public void close() {//虽然可以关门，但这个动作不归我执行
//状态修改
super.context.setLiftState(Context.CLOSING_STATE);
//动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
super.context.getLiftState().close();
}
//停止状态再跑起来，正常的很
@Override
public void run() {
//状态修改
super.context.setLiftState(Context.RUNNING_STATE);
//动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
super.context.getLiftState().run();
}
//停止状态是怎么发生的呢？当然是停止方法执行了
@Override
public void stop() {
System.out.println("电梯停止了...");
}
}
然后我们在测试类中写入代码如下，最后可以发现其会正确执行对应状态下才能执行的方法
public class Client {
public static void main(String[] args) {
//创建环境角色对象
Context context = new Context();
//设置当前电梯状态
context.setLiftState(new ClosingState());
context.open();
context.close();
context.run();
context.stop();
}
}
然后我们来看看其优缺点和使用场景
其实说实话我觉得搞了这么多这玩意最后的代码样式还不如一开始的呢，起码那个好理解多了
观察者模式
现在我们来学习观察者模式，先来看看其定义以及结构
观察者模式介绍
我们可以通过观察者模式实现广播的功能或者是监听某个对象的功能，与这种设计模式最相似现实例子就是公众号订阅更新功能，一旦订阅号更新，则会以广播的形式通知其下的所有用户对象更新的新文章，那么接下来我们就要来完成这么一个公众号更新的例子，先来看看其需求和类图
案例实现
首先我们创建抽象观察者类，其只定义一个更新接口
//抽象观察者类
public interface Observer {
void update(String message);
}
接着我们定义抽象主题角色类，其下含有观察者对象，而且具有添加删除更新的方法，我们可以直接将其理解为是公众号对象，不过我们这里提供的是一个接口
//抽象主题角色类
public interface Subject {
//添加订阅者（添加观察者对象）
void attach(Observer observer);
//删除订阅者
void detach(Observer observer);
//通知订阅者更新消息
void notify(String message);
}
然后我们定义抽象具体的主题角色类，我们这里定义一个集合来存储多个观察者对象，这是当然的，因为一个公众号可以有多个微信用户，其下对应的增加用户，删除用户和更新的方法，更新使用foreach循环调用方法实现
public class SubscriptionSubject implements Subject{
//定义一个集合，用来存储多个观察者对象
private List<Observer> weiXinUserList = new ArrayList<>();
@Override
public void attach(Observer observer) {
weiXinUserList.add(observer);
}
@Override
public void detach(Observer observer) {
weiXinUserList.remove(observer);
}
@Override
public void notify(String message) {
//遍历集合
for (Observer observer : weiXinUserList) {
//调用观察者中的update方法
observer.update(message);
}
}
}
最后我们定义具体观察者类，其就是实现一个更新的方法，当然，我们这里的观察者类其实一个微信用户类，因此我们这里提供保存用户名的属性并且提供构造方法
public class WeiXinUser implements Observer{
private String name;
public WeiXinUser(String name) {
this.name = name;
}
@Override
public void update(String message) {
System.out.println(name+"---"+message);
}
}
最后我们写入我们的测试类的代码如下，可以得到我们想要的结果，三个用户都调用了更新方法
public class Client {
public static void main(String[] args) {
//1.创建公众号对象
SubscriptionSubject subject = new SubscriptionSubject();
//2.订阅公众号
subject.attach(new WeiXinUser("孙悟空"));
subject.attach(new WeiXinUser("猪八戒"));
subject.attach(new WeiXinUser("沙悟净"));
//3.公众号更新，发出消息给订阅者(观察者对象)
subject.notify("黑马更新了");
}
}
然后我们来看看观察者模式的优缺点和使用场景
JDK中提供的实现
在Java中提供了两个接口（分别是抽象目标类和抽象观察者类）用于实现观察者模式，用户只需要实现这两个就可以实现观察者模式，即可以实现监听器或者是广播的效果
首先我们来介绍抽象目标类Observable
其下有一个Vector的集合成员变量，我们直接把它当List集合对象来看待就行了其实，其第一个添加方法会判断集合中是否存在对应的对象，若存在再添加，具体请看源码
public synchronized void addObserver(Observer o) {
if (o == null)
throw new NullPointerException();
if (!obs.contains(o)) {
obs.addElement(o);
}
}
第二个更新的方法本质还是使用for循环来遍历所有对象并调用其下的更新方法，之所以越晚加入就越快得到通知，是因为遍历时其是从后往前遍历的
public void notifyObservers(Object arg) {
Object[] arrLocal;
synchronized (this) {
if (!changed)
return;
arrLocal = obs.toArray();
clearChanged();
}
for (int i = arrLocal.length-1; i>=0; i--)
((Observer)arrLocal[i]).update(this, arg);
}
第三个方法简单来说就是一个布尔类型的变量，该变量的主要作用就是用于判断我们的最初的对象是否进行了更新，若更新则将其赋值为true，然后调用我们的第二个方法，自然会通知，同时通知完之后再调用clearChanged()方法将对应的布尔类型的值设置为false，即是未更新
protected synchronized void setChanged() {
changed = true;
}
然后是抽象观察者类的接口，这个没什么值得说的，直接用就行
然后我们可以做一个警察抓小偷的简单例子来加深理解
首先我们创建小偷对象，其需要继承Obsevable类，其下我们提供名字属性，一旦偷东西我们就调用其父类的标记更新方法和状态更新方法
public class Thief extends Observable {
private String name;
public Thief(String name) {
this.name = name;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void steal() {
System.out.println("小偷：我偷东西了，有没有人来抓我！！！");
super.setChanged(); //changed = true
super.notifyObservers();
}
}
然后我们创建观察者类，令其实现Observer接口，其下提供警察的名字属性，同时我们重写父类接口的更新方法
public class Policemen implements Observer {
private String name;
public Policemen(String name) {
this.name = name;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
@Override
public void update(Observable o, Object arg) {
System.out.println("警察：" + ((Thief) o).getName() + "，我已经盯你很久了，你可以保持沉默，但你所说的将成为呈堂证供！！！");
}
}
最后我们可以写入我们的测试类的代码如下，我们这里第8行的代码相当于是让警察盯住小偷，也相当于是用户订阅了某个公众号（当然，这里小偷是公众号），一旦小偷的状态更新，我们就调用其下的更新方法，让警察抓小偷，这很好理解，就类似于公众号，功能几乎一样的，只不过我们这里提供了一个实现方式而已，我们可以通过这个接口直接实现它
public class Client {
public static void main(String[] args) {
//创建小偷对象
Thief t = new Thief("隔壁老王");
//创建警察对象
Policemen p = new Policemen("小李");
//让警察盯着小偷
t.addObserver(p);
//小偷偷东西
t.steal();
}
}
中介者模式
现在我们来学习中介者模式，先来看看其概述
简单来说就是不要和陌生人讲话的原则，如果不同对象建立直接访问的关系，那么最终得到的对象就会是十分复杂的，因此我们这里提供中介者，让不同对象之间关联中介者，这样可以减低其耦合性
这个很好理解，就好像我们买房子的时候，我们一般不会直接去找卖房子的人，而是寻找对应的房屋中介，通过房屋中介来完成购房，如果我们需要什么，我们也直接去找房屋中介即可，不需要去关心具体的房主
然后我们来看看中介者模式的定义和结构
中介者模式介绍
同样的，我们来完成一个案例来加深我们对该模式的理解，先来看看案例需求以及其类图
案例实现
首先我们创建抽象中介者类，其可以是一个接口，也可以是抽象类，我们这里设置为抽象类的形式，其下提供一个交流的抽象方法，传入的参数是用于交流的信息和发入交流信息的同事类
//抽象中介者类
public abstract class Mediator {
public abstract void constact(String message,Person person);
}
首先我们创建抽象的同事类，其是一个抽象类，具有名字和中介者属性，提供给其对应的构造方法即可
//抽象同事类
public abstract class Person {
protected String name;
protected Mediator mediator;
public Person(String name, Mediator mediator) {
this.name = name;
this.mediator = mediator;
}
}
接着我们创建具体的同时角色类，在这个案例里代表的其实就是房主，我们令其实现抽象同事类，首先实现其构造方法，然后我们提供两个方法，第一个方法是和中介沟通的方法，直接传入信息和当前类的对象到中介者类中的沟通方法即可，然后还有一个获取信息的方法，打印房主名字和信息即可
//具体的同事角色类
public class HouseOwner extends Person{
public HouseOwner(String name, Mediator mediator) {
super(name, mediator);
}
//和中介联系（沟通）
public void constact(String message){
mediator.constact(message,this);
}
//获取信息
public void getMessage(String message) {
System.out.println("房主"+name+"获取到的信息是"+message);
}
}
然后我们还要创建一个买房对象的具体同事角色类，同样提供对应的两个方法，无非做一些调试而已
//具体的同事角色类
public class Tenant extends Person{
public Tenant(String name, Mediator mediator) {
super(name, mediator);
}
//和中介联系（沟通）
public void constact(String message){
mediator.constact(message,this);
}
//获取信息
public void getMessage(String message) {
System.out.println("租房者"+name+"获取到的信息是"+message);
}
}
最后我们创建具体中介者角色，其下聚合了房主和租房者对象，提供对应的getandset方法然后重写父类的constact方法，我们这里对传入的对象进行判断，若其是卖房者，则调用买房者的获得买房者信息的方法，反之则调用卖房者的获得对应信息的方法
//具体的中介者角色类
public class MediatorStructure extends Mediator{
//聚合房主和租房者对象
private HouseOwner houseOwner;
private Tenant tenant;
public HouseOwner getHouseOwner() {
return houseOwner;
}
public void setHouseOwner(HouseOwner houseOwner) {
this.houseOwner = houseOwner;
}
public Tenant getTenant() {
return tenant;
}
public void setTenant(Tenant tenant) {
this.tenant = tenant;
}
@Override
public void constact(String message, Person person) {
if(person==houseOwner){
tenant.getMessage(message);
}else {
houseOwner.getMessage(message);
}
}
}
最后我们可以在测试类中写入代码如下，我们首先创建中介者、租房者、房主对象，然后将对应的房主和租房者聚合到中介者对象中，然后我们调用租房者的沟通方法，其就会调用中介者的沟通方法，中介者判断到其是租房者后，其就会将对应的信息传达给房主，这样就完成了一个信息的转调，对于房主调用对应的沟通方法而言，其过程也是一样的
public class Client {
public static void main(String[] args) {
//创建中介者对象
MediatorStructure mediator = new MediatorStructure();
//创建租房者对象
Tenant tenant = new Tenant("李四",mediator);
//创建房主对象
HouseOwner houseOwner = new HouseOwner("张三",mediator);
//中介者要知道具体的房主和租房者
mediator.setTenant(tenant);
mediator.setHouseOwner(houseOwner);
tenant.constact("我要租三室房");
houseOwner.constact("我这里有三室的房子");
}
}
最后我们来看看中介者模式的优缺点和使用场景
迭代器模式
现在我们来学习迭代器模式，这个模式就要提及我们远古时候的记忆了，以前学习过的东西给我们埋伏笔了属于是
首先我们先来看看其概述以及结构
迭代器模式介绍
看着就感觉非常的相似，非常的有感觉啊，好像我们之前学习集合的时候就学过这玩意啊
我们照样通过一个案例来加深我们对该模式的理解，先看看案例需求以及类图
案例实现
首先我们需要创建对应的学生类，然后提供对应的方法
package com.login;
public class Student {
private String name;
private String number;
@Override
public String toString() {
return "Student{" +
"name='" + name + ''' +
", number='" + number + ''' +
'}';
}
public Student() {
}
public Student(String name, String number) {
this.name = name;
this.number = number;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
}
然后我们创建抽象迭代器接口，其下定义两个方法，判断是否还有元素以及获取下一个元素
//抽象迭代器角色接口
public interface StudentIterator {
//判断是否还有元素
boolean hasNext();
//获取下一个元素
Student next();
}
接着我们创建具体的得带器角色类，其下提供两个属性，第一个是集合对象，第二个是一个坐标，用于记录遍历时的位置，其下要实现接口中的两个方法，第一个方法是判断还有没有下一个元素，我们直接判断当前位置是否到达集合最大位置即可，第二个方法是获得集合中指定位置的元素，直接获得对应坐标的元素再令下标+1即可
//具体迭代器角色类
public class StudentIteratorImpl implements StudentIterator{
private List<Student> list;
private int position = 0;//用于记录遍历时的位置
public StudentIteratorImpl(List<Student> list) {
this.list = list;
}
@Override
public boolean hasNext() {
return position<list.size();
}
@Override
public Student next() {
//从集合中获取指定位置的元素
return list.get(position++);
}
}
然后我们再创建一个抽象聚合接口，其下有添加、删除学生功能，而最重要的是获取迭代器对象的功能
//抽象聚合接口
public interface StudentAggregate {
//添加学生功能
void addStudent(Student stu);
//删除学生功能
void removeStudent(Student stu);
//获取迭代器对象功能
StudentIterator getStudentIterator();
}
接着我们创建抽象聚合的即可的实现类，可以看到我们这里实现这三个方法，而获取迭代器对象的方法就是直接返回一个迭代器对象即可
public class StudentAggregateImpl implements StudentAggregate{
private List<Student> list = new ArrayList<>();
@Override
public void addStudent(Student stu) {
list.add(stu);
}
@Override
public void removeStudent(Student stu) {
list.remove(stu);
}
@Override
public StudentIterator getStudentIterator() {
return new StudentIteratorImpl(list);
}
}
最后我们可以在测试类中写入我们的代码如下，首先我们创建聚合对象，接着往其下添加四个学生对象，然后获取迭代器对象再通过while循环遍历即可
public class Client {
public static void main(String[] args) {
//创建聚合对象
StudentAggregateImpl aggregate = new StudentAggregateImpl();
//添加元素
aggregate.addStudent(new Student("张三","001"));
aggregate.addStudent(new Student("李四","002"));
aggregate.addStudent(new Student("王五","003"));
aggregate.addStudent(new Student("赵六","004"));
//遍历聚合对象
//1.获取迭代器对象
StudentIterator iterator = aggregate.getStudentIterator();
//2.遍历
while (iterator.hasNext()){
//3.获取元素
Student next = iterator.next();
System.out.println(next.toString());
}
}
}
最后我们来看看其优缺点是使用场景
JDK源码解析
这个没啥值得说的，以前都学过了都，直接看图吧
访问者模式
现在我们来学习下访问者模式，首先我们来看看其定义和结构
访问者模式介绍
当然，只看上面的说明肯定是空洞的，我们同样通过一个例子来加深理解，先来看看其需求和类图
案例实现
那么首先我们创建抽象访问者角色，其下提供两个喂食方法，分别喂食我们的猫和狗，为什么不统一用Animal接口来表示？因为如果使用统一的接口表示，后续我们喂食的时候将无法具体对应喂食到某个宠物，只能喂食整个宠物一个大的类别
//抽象访问者角色
public interface Person {
void feed(Cat cat);
void feed(Dog dog);
}
然后我们定义主人类和路人类，其都实现Person类并重写其下的方法（只展示一个）
public class Owner implements Person{
@Override
public void feed(Cat cat) {
System.out.println("主人喂食猫");
}
@Override
public void feed(Dog dog) {
System.out.println("主人喂食狗");
}
}
接着我们定义抽象动物类，其实抽象元素角色，其下我们定义一个可以接受人访问的方法
public interface Animal {
//接受访问者访问的功能
void accept(Person person);
}
然后定义具体的宠物类实现动物类，重写其方法，直接调用人的喂食方法，将当前的宠物对象传入即可
public class Dog implements Animal{
@Override
public void accept(Person person) {
person.feed(this);//访问者给宠物猫喂食
System.out.println("好吃汪...");
}
}
最后我们要创建结构对象角色，这里代表的主人家类，其下组合了一个宠物对象的集合，具有添加宠物和遍历宠物的功能，遍历宠物就直接调用宠物里的接受访问的方法即可，即是可以让外人或者是主人直接访问所有的宠物
//对象结构类
public class Home {
//声明一个集合对象，用来存储元素对象
private List<Animal> animals = new ArrayList<>();
//添加元素功能
public void add(Animal animal){
animals.add(animal);
}
public void action(Person person){
//遍历集合，获取每一个元素，让访问者访问每一个元素
for (Animal animal : animals) {
animal.accept(person);
}
}
}
然后我们可以写入我们的测试类代码如下，我们这里创建主人类，然后往其中添加宠物，接着分别创建主人对象和路人对象并调用主人家里的统一访问方法，最后可以得到主人和路人都分别给宠物进行了喂食的结果
public class Client {
public static void main(String[] args) {
//创建Home对象
Home home = new Home();
//添加元素到Home对象中
home.add(new Dog());
home.add(new Cat());
//创建主人对象
Owner owner = new Owner();
//让主人喂食所有的宠物
home.action(owner);
//创建路人对象
Someone someone = new Someone();
home.action(someone);
}
}
接着我们来看看其优缺点和使用场景
扩展内容-分派
实际上，我们的访问者模式是使用到了一种双分派的技术，我们这里就来扩展一下这个知识点
分派又两种，分别是静态分派和动态分派，我们来看看他们三者的描述
静态分派可以简单理解为是方法重载，其是发生在编译时期，而动态分派是发生在运行时期，可以动态置换掉某个方法
我们先来讲讲动态分派的例子，请看下图
所以简单来说，我们可以将都动态分派理解为多态，Java编译器在编译时期会对对象的类型进行判断，此处判断的类型是静态类型，但是对方法的调用是根据对象的真实类型，而不是静态类型，因此我们调用对应的方法时会执行其真实类型里的方法
接着我们再来说说静态分派，方法重载可以简单理解为是静态分派，我们来看看下图中的例子
这个结果似乎有些楚人意料，之所以会产生这个结果是因为重载方法的分派是根据静态类型进行的，这个分派过程在编译时期就完成了。这样说可能有些云里雾里，简单来说就是只有我们调用对象中的方法的时候其才会调用其真实对象，而如果我们只是给其定义了一个类型然后直接传入给对应类调用方法，那么最终其会认为这三个类都是我们之前指定的类型然后进入到对应的方法中并执行，具体就体现在上面的三个结果都是animal
最后我们来谈谈什么是双分派，简单来说，双分派就是在选择一个方法的时候，不仅仅要根据消息接收者的运行时区别，还要根据参数时的运行区别
我们这里首先创建动物对象，而其下定义一个Execute对象的方法，该方法会调用Execute对象的excute方法，调用内部的方法需要传入一个具体的动物对象，其会根据对应的动物对象来执行对应的方法。
那么我们在测试类中先创建这个三个方法，然后创建一个Execute对象，接着我们分别调用三个对象的accept方法传入exe对象，此处我们调用子类的真实方法，就完成的动态分派，然后我们在对应的子类的方法中，会将自身对象传入给exe对象中，此处就是实现了静态分派，定义一个对象并传入，而exe类又会根据对应的类执行对应的方法，最终就能够得到我们想要的结果，那么在这个过程中我们就实现了双分派
双分派实现动态绑定的本质，就是在重载方法委派的前面加上了继承体系中覆盖的环节，由于覆盖是动态的，所以重载就是动态的了
简单来说，双分派的作用就是可以实现我们的动态重载，虽然比较麻烦就是
备忘录模式
现在我们来学习备忘录模式，先来看看其概述
然后我们来看看其定义的结构
备忘录模式介绍
同样的我们通过一个案例来加深理解，来看看案例需求
实现这种案例有两种方式，分别是白箱和黑箱，我们先来实现白箱方式，所谓白箱方式指的是对备忘录角色的任何一个对象都提供宽接口，备忘录角色内部存储的状态对所有角色公开，来看看类图
白箱实现
首先我们创建备忘录角色类，该角色类可以保存我们的状态，我们的角色属性就生命、攻击、防御三种，所以我们这里只往内部设置这三个属性，然后提供对应的方法
//备忘录角色类
public class RoleStateMemento {
private int vit; //生命
private int atk; //攻击
private int def; //防御
public RoleStateMemento(int vit, int atk, int def) {
this.vit = vit;
this.atk = atk;
this.def = def;
}
public RoleStateMemento() {
}
public int getVit() {
return vit;
}
public void setVit(int vit) {
this.vit = vit;
}
public int getAtk() {
return atk;
}
public void setAtk(int atk) {
this.atk = atk;
}
public int getDef() {
return def;
}
public void setDef(int def) {
this.def = def;
}
}
然后创建发起人角色，其在我们案例中代表的是游戏角色类，我们给予其赋予生命、攻击、防御三个属性，提供对应的构造和setandget方法，然后我们体用初始化内部状态的方法，给对应的属性赋值，接着提供一个保存角色状态功能的方法，返回一个保存角色状态的对象，然后我们再提供一个恢复角色状态的方法，要求提供一个角色状态对象，然后内部会自动获得里面的值并赋予到原来的对象中
//游戏角色类（发起人角色）
public class GameRole {
private int vit; //生命
private int atk; //攻击
private int def; //防御
//初始化内部状态
public void initState() {
this.vit=100;
this.atk=100;
this.def=100;
}
//战斗
public void fight() {
this.vit=0;
this.atk=0;
this.def=0;
}
//保存角色状态功能
public RoleStateMemento saveState() {
return new RoleStateMemento(vit,atk,def);
}
//恢复角色状态
public void recoverState(RoleStateMemento roleStateMemento){
//将备忘录对象中存储的状态赋值给当前对象的成员
this.vit= roleStateMemento.getVit();
this.atk= roleStateMemento.getAtk();
this.def= roleStateMemento.getDef();
}
//展示状态功能
public void stateDisplay() {
System.out.println(this.toString());
}
@Override
public String toString() {
return "GameRole{" +
"vit=" + vit +
", atk=" + atk +
", def=" + def +
'}';
}
public int getVit() {
return vit;
}
public void setVit(int vit) {
this.vit = vit;
}
public int getAtk() {
return atk;
}
public void setAtk(int atk) {
this.atk = atk;
}
public int getDef() {
return def;
}
public void setDef(int def) {
this.def = def;
}
}
最后我们创建管理者角色，其下聚合了备忘录类，还提供了一些必要的方法
public class RoleStateCaretaker {
//声明RoleStateMemento类型的变量
private RoleStateMemento roleStateMemento;
public RoleStateCaretaker(RoleStateMemento roleStateMemento) {
this.roleStateMemento = roleStateMemento;
}
public void setRoleStateMemento(RoleStateMemento roleStateMemento) {
this.roleStateMemento = roleStateMemento;
}
public RoleStateMemento getRoleStateMemento() {
return roleStateMemento;
}
public RoleStateCaretaker() {
}
}
接着我们可以写入我们的测试类代码如下，我们这里先创建游戏对象，然后创建游戏管理者对象，接着我们往管理者对象中设置一个游戏保存的状态对象，直接调用游戏角色内部的方法即可，接着调用游戏角色的恢复方法，传入一个管理者类中保存的游戏状态类即可完成恢复
public class Client {
public static void main(String[] args) {
System.out.println("h之前");
//创建游戏角色对象
GameRole gameRole = new GameRole();
gameRole.initState();//初始化状态操作
gameRole.stateDisplay();
//将该游戏角色内部状态进行备份
//创建管理者对象
RoleStateCaretaker roleStateCaretaker = new RoleStateCaretaker();
roleStateCaretaker.setRoleStateMemento(gameRole.saveState());
System.out.println("h之后");
//损耗严重
gameRole.fight();
gameRole.stateDisplay();
System.out.println("恢复之前的状态");
gameRole.recoverState(roleStateCaretaker.getRoleStateMemento());
gameRole.stateDisplay();
}
}
- 黑箱备忘录模式
那么接着我们来用黑箱备忘录模式来实现这个案例，其实现的方式就是提供一个备忘录接口，然后将备忘录类设计为发起人类的内部成员类
黑箱实现
首先我们创建备忘录接口，其用于对外提供窄接口
//备忘录接口，对外提供窄接口
public interface Memento {
}
然后我们创建管理者类，其拥有我们刚刚定义的接口属性，同时提供对应的getandset方法
public class RoleStateCaretaker {
//声明Memento类型的变量
private Memento memento;
public Memento getMemento() {
return memento;
}
public void setMemento(Memento memento) {
this.memento = memento;
}
}
然后我们定义游戏角色类，内部再定义一个保存状态的类，令其实现我们的接口，然后其下提供对应的方法即可
//游戏角色类（发起人角色）
public class GameRole {
private int vit; //生命
private int atk; //攻击
private int def; //防御
//初始化内部状态
public void initState() {
this.vit=100;
this.atk=100;
this.def=100;
}
//战斗
public void fight() {
this.vit=0;
this.atk=0;
this.def=0;
}
//保存角色状态功能
public Memento saveState() {
return new RoleStateMemento(vit,atk,def);
}
//恢复角色状态
public void recoverState(Memento memento){
RoleStateMemento roleStateMemento = (RoleStateMemento) memento;
//将备忘录对象中存储的状态赋值给当前对象的成员
this.vit= roleStateMemento.getVit();
this.atk= roleStateMemento.getAtk();
this.def= roleStateMemento.getDef();
}
//展示状态功能
public void stateDisplay() {
System.out.println(this.toString());
}
@Override
public String toString() {
return "GameRole{" +
"vit=" + vit +
", atk=" + atk +
", def=" + def +
'}';
}
public int getVit() {
return vit;
}
public void setVit(int vit) {
this.vit = vit;
}
public int getAtk() {
return atk;
}
public void setAtk(int atk) {
this.atk = atk;
}
public int getDef() {
return def;
}
public void setDef(int def) {
this.def = def;
}
private class RoleStateMemento implements Memento{
private int vit; //生命
private int atk; //攻击
private int def; //防御
public RoleStateMemento() {
}
public RoleStateMemento(int vit, int atk, int def) {
this.vit = vit;
this.atk = atk;
this.def = def;
}
public int getVit() {
return vit;
}
public void setVit(int vit) {
this.vit = vit;
}
public int getAtk() {
return atk;
}
public void setAtk(int atk) {
this.atk = atk;
}
public int getDef() {
return def;
}
public void setDef(int def) {
this.def = def;
}
}
}
最后我们写入我们的测试类的代码如下，最终也可以得到同样的效果
public class Client {
public static void main(String[] args) {
System.out.println("h之前");
//创建游戏角色对象
GameRole gameRole = new GameRole();
gameRole.initState();//初始化状态操作
gameRole.stateDisplay();
//将该游戏角色内部状态进行备份
//创建管理者对象
RoleStateCaretaker roleStateCaretaker = new RoleStateCaretaker();
roleStateCaretaker.setMemento(gameRole.saveState());
System.out.println("h之后");
//损耗严重
gameRole.fight();
gameRole.stateDisplay();
System.out.println("恢复之前的状态");
gameRole.recoverState(roleStateCaretaker.getMemento());
gameRole.stateDisplay();
}
}
而且我们这样定义，我们的管理者类就无法随意获取到我们的状态类并修改其内容了，如果其采用向下转型的话，那么会报类型转换异常
值得一提的是，我们将该状态类即使放到外面来，不定义成其内部的类，也是可行的，那为什么我们这里就要定义成内部类呢？这个问题值得我们思考
最后我们来看看其优缺点和使用场景
解释器模式
现在我们来学习行为型模式里的最后一个模式，解释器模式，我们先来看看其概述
也就是说，我们的确可以通过几个简单的方法来实现加减法，但是这样实现的内容不但形式单一，而且不符合要求，那么我们就需要一种可以翻译的机器，可以解析我们传入的运算序列
我们可以将运算符和数字都看做结点，那么我们目标就是希望能够对逐个结点进行读取并解析运算，这就是解释器模式的思维
解释器模式介绍
我们的解释器就是要解析出来的语句的含义，那么剩下的问题就在于我们要如何描述我们的语法规则
上面的图中，expression表达的是我们的表达式，表达式中的 | 指的是与操作，也就是说，我们的一个表达式可以由value，plus以及minus组成，这三个在下面都有定义
我们的plus操作应该由两个表达式以及一个+号连接组成，minus操作则是有-号连接，而value的值我们这里规定只能为Integer类型的值，上面的内容则定义了我们的语法结构的形式规则，其本身就作为一个文法
在计算机科学中具有抽象语法树结构，简称语法树，我们一般用这种结构来表达符合文法结构规则的句子
接着我们来通过一个案例来加深我们对解释器模式的理解，首先我们来看看其案例的需求和类图
案例实现
首先我们创建抽象表达式类，其是一个抽象类，定义了一个抽象方法，该方法需要传入一个环境类（当前未创建），然后返回一个int类型的结果
//抽象表达式类
public abstract class AbstractExpression {
public abstract int interpret(Context context);
}
然后我们定义我们的环境角色类，其下拥有Map集合类，用来存储变量以及对应的值，我们还提供了添加变量的方法，需要提供保存变量的Variable类以及具体的值（保存变量的类还未定义），还有一个获取对应值的方法
//环境角色类
public class Context {
//定义一个Map集合，用来存储变量及对应的值
private Map<Variable,Integer> map = new HashMap<>();
//添加变量的功能
public void assign(Variable var,Integer value){
map.put(var,value);
}
//根据变量获取对应的值
public int getValue(Variable var){
return map.get(var);
}
}
接着我们定义封装变量的类，这里我们往其中定义一个封装变量的类，其当然要继承我们的抽象表达式类，其中提供一个String属性用于保存我们的变量名，重写的方法中我们直接返回变量的值即可，因此我们这里直接调用传入的环境类的getValue方法，传入当前的变量对象，即可从环境类中的map集合中获得我们所需要的值
最后我们还重写了toString方法，重写这个方法是为了让我们后期能够正确打印我们的文法语句
//封装变量的类
public class Variable extends AbstractExpression{
//声明存储变量名的成员变量
private String name;
public Variable(String name) {
this.name = name;
}
@Override
public int interpret(Context context) {
//直接返回变量的值
return context.getValue(this);
}
@Override
public String toString() {
return name;
}
}
接着我们定义我们的加法表达式类，其下应该聚合了两个表达式类的属性，分别保存+号左右两边的内容，我们重写父类的方法，让我们的方法调用我们的属性中的计算结果的方法并将环境对象继续传入，最后我们提供一个toString方法用于打印我们的语法表达式
//加法表达式类
public class Plus extends AbstractExpression{
//+号左边的表达式
private AbstractExpression left;
//+号右边的表达式
private AbstractExpression right;
public Plus(AbstractExpression left,AbstractExpression right){
this.left=left;
this.right=right;
}
@Override
public int interpret(Context context) {
//将左边表达式的结果和右边表达式的结果进行相加
return left.interpret(context)+right.interpret(context);
}
@Override
public String toString() {
return "("+left.toString()+"+"+right.toString()+")";
}
}
同样对于减法表达式类也是一样的
//减法表达式类
public class Minus extends AbstractExpression{
//-号左边的表达式
private AbstractExpression left;
//-号右边的表达式
private AbstractExpression right;
public Minus(AbstractExpression left, AbstractExpression right){
this.left=left;
this.right=right;
}
@Override
public int interpret(Context context) {
//将左边表达式的结果和右边表达式的结果进行相减
return left.interpret(context)-right.interpret(context);
}
@Override
public String toString() {
return "("+left.toString()+"-"+right.toString()+")";
}
}
最后我们再测试类中写入我们的代码如下，这里我们来解释下我们的这份代码的执行过程，因为还是有点复杂的，先解释下好，免得以后看不懂
首先我们创建对应的环境变量，然后我们创建多个变量对象，提供唯一标识，然后我们将对应的变量存储到我们的环境对象中，这里我们还设置了对应的值，分别是1234，接着我们来获取我们的抽象语法树，我们这里通过直接创建对应的类的方式来指定构建我们的语法树，而每个语法树中都应该要设置两个变量对象，每一个new的对象代表的是要两个变量要执行的运算，并且其都会返回一个新的保存变量对象，最终我们构造出了我们的语法树
然后我们调用语法树中的计算方法，我们的语法树最开始的真实对象是Minus对象，首先我们就调用Minus类中的interpret方法，然后我们需要调用两个保存的变量类中的interpret方法获得对应的值用于计算，如果最终我们往内部传入的值并不是一个变量类，而是一个计算类，那么其就会递归调用方法，继续进入到同样的方法中去执行计算过程，而由于我们总是能保证我们任何一个计算类最终总是保存了两个变量类的，因此最终我们虽然调用同样的方法，但是由于类的特殊性，我们总是能够让我们的方法正确停止，这也是为什么我们的保存变量的类也叫做终结符表达式，计算类又被称为非终结符表达式
public class Client {
public static void main(String[] args) {
//创建环境对象
Context context = new Context();
//创建多个变量对象
Variable a = new Variable("a");
Variable b = new Variable("b");
Variable c = new Variable("c");
Variable d = new Variable("d");
//将变量存储到环境对象中
context.assign(a,1);
context.assign(b,2);
context.assign(c,3);
context.assign(d,4);
//获取抽象语法树 a+b-c+d
AbstractExpression expression = new Minus(a,new Plus(new Minus(b,c),d));
//解释（计算）
int interpret = expression.interpret(context);
System.out.println(expression+"="+interpret);
}
}
最后我们可以得到这个结果，左边是我们对应的语法树，右边是我们的结果
(a-((b-c)+d))=-2
最后我们来看看该模式的优缺点和使用场景
学完了所有内容之后，现在我们来学习如果用我们之前学过的设计模式来自定义Spring框架，当然这里只是一个非常简单的自定义Spring框架，主要还是复习一下
在自定义Spring框架前，我们先来回顾一下Spring框架的使用、
- 配置文件使用Spring管理类
首先我们要使用Spring管理类首先要引入Spring的依赖，其坐标如下
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
然后我们创建对应的三层架构，首先我们创建dao包，然后创建dao层接口，接着创建其实现类，只输出一句话
public class UserDaoImpl implements UserDao {
@Override
public void add() {
System.out.println("UserDao...");
}
}
同样创建服务层接口的实现类，其下拥有Dao类属性，我们提供set方法并调用Dao层的方法
public class UserServiceImpl implements UserService {
//声明一个UserDao类型的变量
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
@Override
public void add() {
System.out.println("UserService...");
userDao.add();
}
}
接着我们创建配置文件，名为applicationContext.xml（其实一般也就是这个名字），接着我们通过bean标签让我们的userService的值自动装备，并给其下的Dao属性配置property标签赋值
同理我们还做了userdao的对象的自动注入
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
<property name="userDao" ref="userDao"></property>
</bean>
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"></bean>
</beans>
最后我们写入控制层的代码如下，我们这里首先获得spring的容器对象，然后获得通过传入类名和字节码文件获得容器中管理的对象，最后调用该对象的方法，可以在控制台上得到我们类运行的内容
public class UserController {
public static void main(String[] args) {
//1.创建spring的容器对象
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//2.从容器对象中获取userService对象
UserService userService = applicationContext.getBean("userService", UserService.class);
//3.调用userService进行业务逻辑处理
userService.add();
}
}
此时我们的Spring管理就已经实现了，我们这里没有直接创建我们的类，但是我们却正确调用我们的类中的方法，我们的Spring帮我们自动创建并管理了这些类
- Spring核心功能结构
我们先来看看Spring核心容器的概述图
核心容器由 beans、core、context 和 expression（Spring Expression Language，SpEL）4个模块组成。
- spring-beans和spring-core模块是Spring框架的核心模块，包含了控制反转（Inversion of Control，IOC）和依赖注入（Dependency Injection，DI）。
- BeanFactory使用控制反转对应用程序的配置和依赖性规范与实际的应用程序代码进行了分离。BeanFactory属于延时加载，也就是说在实例化容器对象后并不会自动实例化Bean，只有当Bean被使用时，BeanFactory才会对该 Bean 进行实例化与依赖关系的装配。
- spring-context模块构架于核心模块之上，扩展了BeanFactory，为它添加了Bean生命周期控制、框架事件体系及资源加载透明化等功能。
- 该模块还提供了许多企业级支持，如邮件访问、远程访问、任务调度等，ApplicationContext 是该模块的核心接口，它的超类是 BeanFactory。与BeanFactory不同，ApplicationContext实例化后会自动对所有的单实例Bean进行实例化与依赖关系的装配，使之处于待用状态。
- spring-context-support模块是对Spring IoC容器及IoC子容器的扩展支持。
- spring-context-indexer模块是Spring的类管理组件和Classpath扫描组件。
- spring-expression 模块是统一表达式语言（EL）的扩展模块，可以查询、管理运行中的对象，同时也可以方便地调用对象方法，以及操作数组、集合等。它的语法类似于传统EL，但提供了额外的功能，最出色的要数函数调用和简单字符串的模板函数。EL的特性是基于Spring产品的需求而设计的，可以非常方便地同Spring IoC进行交互。
接下来我们先来学习下bean
- Bean概述
Spring 就是面向 Bean 的编程（BOP,Bean Oriented Programming），Bean 在 Spring 中处于核心地位。Bean对于Spring的意义就像Object对于OOP的意义一样，Spring中没有Bean也就没有Spring存在的意义。Spring IoC容器通过配置文件或者注解的方式来管理bean对象之间的依赖关系。
spring中bean用于对一个类进行封装。如下面的配置：
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
<property name="userDao" ref="userDao"></property>
</bean>
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"></bean>
为什么Bean如此重要呢？
- spring 将bean对象交由一个叫IOC容器进行管理。
- bean对象之间的依赖关系在配置文件中体现，并由spring完成。
接着我们来学习bean里面的BeanFactory
- BeanFactory解析
Spring中Bean的创建是典型的工厂模式，这一系列的Bean工厂，即IoC容器，为开发者管理对象之间的依赖关系提供了很多便利和基础服务，在Spring中有许多IoC容器的实现供用户选择，其相互关系如下图所示
其中，BeanFactory作为最顶层的一个接口，定义了IoC容器的基本功能规范，BeanFactory有三个重要的子接口：ListableBeanFactory、HierarchicalBeanFactory和AutowireCapableBeanFactory。但是从类图中我们可以发现最终的默认实现类是DefaultListableBeanFactory，它实现了所有的接口。
那么为何要定义这么多层次的接口呢？
每个接口都有它的使用场合，主要是为了区分在Spring内部操作过程中对象的传递和转化，对对象的数据访问所做的限制。例如，
- ListableBeanFactory接口表示这些Bean可列表化。
- HierarchicalBeanFactory表示这些Bean 是有继承关系的，也就是每个 Bean 可能有父 Bean
- AutowireCapableBeanFactory 接口定义Bean的自动装配规则。
这三个接口共同定义了Bean的集合、Bean之间的关系及Bean行为。最基本的IoC容器接口是BeanFactory，来看一下它的源码：
public interface BeanFactory {
String FACTORY_BEAN_PREFIX = "&";
//根据bean的名称获取IOC容器中的的bean对象
Object getBean(String name) throws BeansException;
//根据bean的名称获取IOC容器中的的bean对象，并指定获取到的bean对象的类型，这样我们使用时就不需要进行类型强转了
<T> T getBean(String name, Class<T> requiredType) throws BeansException;
Object getBean(String name, Object... args) throws BeansException;
<T> T getBean(Class<T> requiredType) throws BeansException;
<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);
//判断容器中是否包含指定名称的bean对象
boolean containsBean(String name);
//根据bean的名称判断是否是单例
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
@Nullable
Class<?> getType(String name) throws NoSuchBeanDefinitionException;
String[] getAliases(String name);
}
在BeanFactory里只对IoC容器的基本行为做了定义，根本不关心你的Bean是如何定义及怎样加载的。正如我们只关心能从工厂里得到什么产品，不关心工厂是怎么生产这些产品的。
BeanFactory有一个很重要的子接口，就是ApplicationContext接口，该接口主要来规范容器中的bean对象是非延时加载，即在创建容器对象的时候就对象bean进行初始化，并存储到一个容器中。
要知道工厂是如何产生对象的，我们需要看具体的IoC容器实现，Spring提供了许多IoC容器实现，比如：
- ClasspathXmlApplicationContext : 根据类路径加载xml配置文件，并创建IOC容器对象。
- FileSystemXmlApplicationContext ：根据系统路径加载xml配置文件，并创建IOC容器对象。
- AnnotationConfigApplicationContext ：加载注解类配置，并创建IOC容器。
然后我们来学习下BeanDefinition
- BeanDefinition解析
Spring IoC容器管理我们定义的各种Bean对象及其相互关系，而Bean对象在Spring实现中是以BeanDefinition来描述的，如下面配置文件
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"></bean>
bean标签还有很多属性：
scope、init-method、destory-method等。
简单来说，我们的bean中的标签都是被封装好的，而这些就是通过BeanDefinition封装的
接着我们来学习下BeanDefinitionReader
- BeanDefinitonReader解析
Bean的解析过程非常复杂，功能被分得很细，因为这里需要被扩展的地方很多，必须保证足够的灵活性，以应对可能的变化。Bean的解析主要就是对Spring配置文件的解析。这个解析过程主要通过BeanDefinitionReader来完成，看看Spring中BeanDefinitionReader的类结构图，如下图所示
上面所说的内容简单来说其实就是我们的BeanDefinitionReader有多个子实现类，分别对应不同的解析情况
接着来看看看看BeanDefinitionReader接义的功能来理解它具体的作用：
public interface BeanDefinitionReader {
//获取BeanDefinitionRegistry注册器对象
BeanDefinitionRegistry getRegistry();
@Nullable
ResourceLoader getResourceLoader();
@Nullable
ClassLoader getBeanClassLoader();
BeanNameGenerator getBeanNameGenerator();
/*
下面的loadBeanDefinitions都是加载bean定义，从指定的资源中
*/
int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException;
int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException;
int loadBeanDefinitions(String location) throws BeanDefinitionStoreException;
int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException;
}
简单来说我们可以BeanDefinitionReader中都有可以获得注册器对象的方法，并且其下有加载对应的配置文件的方法
然后我们来学习BeanDefinitionRegistry
- BeanDefinitionRegistry解析
BeanDefinitionReader用来解析bean定义，并封装BeanDefinition对象，而我们定义的配置文件中定义了很多bean标签，所以就有一个问题，解析的BeanDefinition对象存储到哪儿？
答案就是BeanDefinition的注册中心，而该注册中心顶层接口就是BeanDefinitionRegistry
该接口定义了所有子实现类都必须具有的方法
public interface BeanDefinitionRegistry extends AliasRegistry {
//往注册表中注册bean
void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException;
//从注册表中删除指定名称的bean
void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
//获取注册表中指定名称的bean
BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
//判断注册表中是否已经注册了指定名称的bean
boolean containsBeanDefinition(String beanName);
//获取注册表中所有的bean的名称
String[] getBeanDefinitionNames();
int getBeanDefinitionCount();
boolean isBeanNameInUse(String beanName);
}
我们可以来看看其下的继承结构图以及其子类用于保存的属性，都是Map其实，只不过是最初创建的大小不同
- 创建容器
最后我们来看看创建容器的过程，简单来说就是调用refresh()方法，对我们的配置文件进行初始化并生成该类到我们的容器中令其管理
学完了所有内容之后，现在我们来学习如果用我们之前学过的设计模式来自定义Spring框架，当然这里只是一个非常简单的自定义Spring框架，主要还是复习一下
在自定义Spring框架前，我们先来回顾一下Spring框架的使用、
配置文件使用Spring管理类
首先我们要使用Spring管理类首先要引入Spring的依赖，其坐标如下
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
然后我们创建对应的三层架构，首先我们创建dao包，然后创建dao层接口，接着创建其实现类，只输出一句话
public class UserDaoImpl implements UserDao {
@Override
public void add() {
System.out.println("UserDao...");
}
}
同样创建服务层接口的实现类，其下拥有Dao类属性，我们提供set方法并调用Dao层的方法
public class UserServiceImpl implements UserService {
//声明一个UserDao类型的变量
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
@Override
public void add() {
System.out.println("UserService...");
userDao.add();
}
}
接着我们创建配置文件，名为applicationContext.xml（其实一般也就是这个名字），接着我们通过bean标签让我们的userService的值自动装备，并给其下的Dao属性配置property标签赋值
同理我们还做了userdao的对象的自动注入
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
<property name="userDao" ref="userDao"></property>
</bean>
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"></bean>
</beans>
最后我们写入控制层的代码如下，我们这里首先获得spring的容器对象，然后获得通过传入类名和字节码文件获得容器中管理的对象，最后调用该对象的方法，可以在控制台上得到我们类运行的内容
public class UserController {
public static void main(String[] args) {
//1.创建spring的容器对象
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//2.从容器对象中获取userService对象
UserService userService = applicationContext.getBean("userService", UserService.class);
//3.调用userService进行业务逻辑处理
userService.add();
}
}
此时我们的Spring管理就已经实现了，我们这里没有直接创建我们的类，但是我们却正确调用我们的类中的方法，我们的Spring帮我们自动创建并管理了这些类
Spring核心功能结构
我们先来看看Spring核心容器的概述图
核心容器由 beans、core、context 和 expression（Spring Expression Language，SpEL）4个模块组成。
- spring-beans和spring-core模块是Spring框架的核心模块，包含了控制反转（Inversion of Control，IOC）和依赖注入（Dependency Injection，DI）。
- BeanFactory使用控制反转对应用程序的配置和依赖性规范与实际的应用程序代码进行了分离。BeanFactory属于延时加载，也就是说在实例化容器对象后并不会自动实例化Bean，只有当Bean被使用时，BeanFactory才会对该 Bean 进行实例化与依赖关系的装配。
- spring-context模块构架于核心模块之上，扩展了BeanFactory，为它添加了Bean生命周期控制、框架事件体系及资源加载透明化等功能。
- 该模块还提供了许多企业级支持，如邮件访问、远程访问、任务调度等，ApplicationContext 是该模块的核心接口，它的超类是 BeanFactory。与BeanFactory不同，ApplicationContext实例化后会自动对所有的单实例Bean进行实例化与依赖关系的装配，使之处于待用状态。
- spring-context-support模块是对Spring IoC容器及IoC子容器的扩展支持。
- spring-context-indexer模块是Spring的类管理组件和Classpath扫描组件。
- spring-expression 模块是统一表达式语言（EL）的扩展模块，可以查询、管理运行中的对象，同时也可以方便地调用对象方法，以及操作数组、集合等。它的语法类似于传统EL，但提供了额外的功能，最出色的要数函数调用和简单字符串的模板函数。EL的特性是基于Spring产品的需求而设计的，可以非常方便地同Spring IoC进行交互。
接下来我们先来学习下bean
Bean概述
Spring 就是面向 Bean 的编程（BOP,Bean Oriented Programming），Bean 在 Spring 中处于核心地位。Bean对于Spring的意义就像Object对于OOP的意义一样，Spring中没有Bean也就没有Spring存在的意义。Spring IoC容器通过配置文件或者注解的方式来管理bean对象之间的依赖关系。
spring中bean用于对一个类进行封装。如下面的配置：
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
<property name="userDao" ref="userDao"></property>
</bean>
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"></bean>
为什么Bean如此重要呢？
- spring 将bean对象交由一个叫IOC容器进行管理。
- bean对象之间的依赖关系在配置文件中体现，并由spring完成。
接着我们来学习bean里面的BeanFactory
BeanFactory解析
Spring中Bean的创建是典型的工厂模式，这一系列的Bean工厂，即IoC容器，为开发者管理对象之间的依赖关系提供了很多便利和基础服务，在Spring中有许多IoC容器的实现供用户选择，其相互关系如下图所示
其中，BeanFactory作为最顶层的一个接口，定义了IoC容器的基本功能规范，BeanFactory有三个重要的子接口：ListableBeanFactory、HierarchicalBeanFactory和AutowireCapableBeanFactory。但是从类图中我们可以发现最终的默认实现类是DefaultListableBeanFactory，它实现了所有的接口。
那么为何要定义这么多层次的接口呢？
每个接口都有它的使用场合，主要是为了区分在Spring内部操作过程中对象的传递和转化，对对象的数据访问所做的限制。例如，
- ListableBeanFactory接口表示这些Bean可列表化。
- HierarchicalBeanFactory表示这些Bean 是有继承关系的，也就是每个 Bean 可能有父 Bean
- AutowireCapableBeanFactory 接口定义Bean的自动装配规则。
这三个接口共同定义了Bean的集合、Bean之间的关系及Bean行为。最基本的IoC容器接口是BeanFactory，来看一下它的源码：
public interface BeanFactory {
String FACTORY_BEAN_PREFIX = "&";
//根据bean的名称获取IOC容器中的的bean对象
Object getBean(String name) throws BeansException;
//根据bean的名称获取IOC容器中的的bean对象，并指定获取到的bean对象的类型，这样我们使用时就不需要进行类型强转了
<T> T getBean(String name, Class<T> requiredType) throws BeansException;
Object getBean(String name, Object... args) throws BeansException;
<T> T getBean(Class<T> requiredType) throws BeansException;
<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);
//判断容器中是否包含指定名称的bean对象
boolean containsBean(String name);
//根据bean的名称判断是否是单例
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
@Nullable
Class<?> getType(String name) throws NoSuchBeanDefinitionException;
String[] getAliases(String name);
}
在BeanFactory里只对IoC容器的基本行为做了定义，根本不关心你的Bean是如何定义及怎样加载的。正如我们只关心能从工厂里得到什么产品，不关心工厂是怎么生产这些产品的。
BeanFactory有一个很重要的子接口，就是ApplicationContext接口，该接口主要来规范容器中的bean对象是非延时加载，即在创建容器对象的时候就对象bean进行初始化，并存储到一个容器中。
要知道工厂是如何产生对象的，我们需要看具体的IoC容器实现，Spring提供了许多IoC容器实现，比如：
- ClasspathXmlApplicationContext : 根据类路径加载xml配置文件，并创建IOC容器对象。
- FileSystemXmlApplicationContext ：根据系统路径加载xml配置文件，并创建IOC容器对象。
- AnnotationConfigApplicationContext ：加载注解类配置，并创建IOC容器。
然后我们来学习下BeanDefinition
BeanDefinition解析
Spring IoC容器管理我们定义的各种Bean对象及其相互关系，而Bean对象在Spring实现中是以BeanDefinition来描述的，如下面配置文件
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"></bean>
bean标签还有很多属性：
scope、init-method、destory-method等。
简单来说，我们的bean中的标签都是被封装好的，而这些就是通过BeanDefinition封装的
接着我们来学习下BeanDefinitionReader
BeanDefinitonReader解析
Bean的解析过程非常复杂，功能被分得很细，因为这里需要被扩展的地方很多，必须保证足够的灵活性，以应对可能的变化。Bean的解析主要就是对Spring配置文件的解析。这个解析过程主要通过BeanDefinitionReader来完成，看看Spring中BeanDefinitionReader的类结构图，如下图所示
上面所说的内容简单来说其实就是我们的BeanDefinitionReader有多个子实现类，分别对应不同的解析情况
接着来看看看看BeanDefinitionReader接义的功能来理解它具体的作用：
public interface BeanDefinitionReader {
//获取BeanDefinitionRegistry注册器对象
BeanDefinitionRegistry getRegistry();
@Nullable
ResourceLoader getResourceLoader();
@Nullable
ClassLoader getBeanClassLoader();
BeanNameGenerator getBeanNameGenerator();
/*
下面的loadBeanDefinitions都是加载bean定义，从指定的资源中
*/
int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException;
int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException;
int loadBeanDefinitions(String location) throws BeanDefinitionStoreException;
int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException;
}
简单来说我们可以BeanDefinitionReader中都有可以获得注册器对象的方法，并且其下有加载对应的配置文件的方法
然后我们来学习BeanDefinitionRegistry
BeanDefinitionRegistry解析
BeanDefinitionReader用来解析bean定义，并封装BeanDefinition对象，而我们定义的配置文件中定义了很多bean标签，所以就有一个问题，解析的BeanDefinition对象存储到哪儿？
答案就是BeanDefinition的注册中心，而该注册中心顶层接口就是BeanDefinitionRegistry
该接口定义了所有子实现类都必须具有的方法
public interface BeanDefinitionRegistry extends AliasRegistry {
//往注册表中注册bean
void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException;
//从注册表中删除指定名称的bean
void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
//获取注册表中指定名称的bean
BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
//判断注册表中是否已经注册了指定名称的bean
boolean containsBeanDefinition(String beanName);
//获取注册表中所有的bean的名称
String[] getBeanDefinitionNames();
int getBeanDefinitionCount();
boolean isBeanNameInUse(String beanName);
}
我们可以来看看其下的继承结构图以及其子类用于保存的属性，都是Map其实，只不过是最初创建的大小不同
创建容器
最后我们来看看创建容器的过程，简单来说就是调用refresh()方法，对我们的配置文件进行初始化并生成该类到我们的容器中令其管理
解析完了Spring框架之后，我们接着来自定义一个SpringIOC的框架，先来看看我们要实现的功能
简单来说我们要自定义一个项目，令其来实现我们之前配置文件里实现的功能
定义bean相关的pojo类
那么首先我们要先定义bean相关的pojo的类，首先我们来定义封装bean的属性的PropertyValue类，该类用于封装bean的属性，体现到上面的配置文件就是封装bean标签的子标签property标签数据
那么我们首先创建PropertyValue类看，然后其下封装三个bean标签中的属性，当然，其都是字符串类型的，接着提供给其所需要的构造方法和setandget方法即可
/**
* 用来封装Bean标签下的property属性
* name属性
* ref属性
* value属性 ： 给基本数据类型及String类型数据赋值
*/
public class PropertyValue {
private String name;
private String ref;
private String value;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getRef() {
return ref;
}
public void setRef(String ref) {
this.ref = ref;
}
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
public PropertyValue(String name, String ref, String value) {
this.name = name;
this.ref = ref;
this.value = value;
}
public PropertyValue() {
}
}
最后我们先来看看我们的包结构吧
MutablePropertyValues类
一个bean标签可以有多个property子标签，每一个property子标签都会被封装成PropertyValue类，而这些类也是需要存储和管理的
所以我们再定义一个MutablePropertyValues类，用来存储并管理多个PropertyValue对象，同样的定义在bean包下
那么我们可以写入我们的代码如下，我们这里使用到了迭代器模式，令其实现对应的迭代器接口，这样我们就可以返回用于遍历的迭代器对象了，我们存储集合对象，就是用集合对象来保存，加上final关键词修饰，提供无参和有参两个构造方法，给予对应的赋予逻辑保证我们的属性不可能为空
然后我们要重写的返回迭代器的方法，我们可以直接调用List集合中提供的返回迭代器的方法即可
package com.itheima.framework.beans;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* 用户存储和管理多个PropertyValue对象
*/
public class MutablePropertyValues implements Iterable<PropertyValue>{
//定义List集合对象，用来存储PropertyValue对象
private final List<PropertyValue> propertyValuesList;
public MutablePropertyValues() {
this.propertyValuesList=new ArrayList<>();
}
public MutablePropertyValues(List<PropertyValue> propertyValuesList) {
if(propertyValuesList==null){
this.propertyValuesList=new ArrayList<>();
}else {
this.propertyValuesList=propertyValuesList;
}
}
//获取所有的PropertyValue对象，返回以数组的形式
public PropertyValue[] getPropertyValues() {
//将集合转换为数组并返回
return propertyValuesList.toArray(new PropertyValue[0]);
}
//根据name属性值获取PropertyValue对象
public PropertyValue getPropertyValue(String propertyName) {
//遍历集合对象
for (PropertyValue propertyValue : propertyValuesList) {
if(propertyValue.getName().equals(propertyName)){
return propertyValue;
}
}
return null;
}
//判断集合是否为空
public boolean isEmpty() {
return propertyValuesList.isEmpty();
}
//添加PropertyValue对象
public MutablePropertyValues addPropertyValue(PropertyValue pv) {
//判断集合中存储的PropertyValue对象是否和传递进来的重复了，如果重复则进行覆盖
for (int i = 0; i < propertyValuesList.size(); i++) {
//获取集合中每一个PropertyValue对象
PropertyValue propertyValue = propertyValuesList.get(i);
if(propertyValue.getName().equals(pv.getName())){
propertyValuesList.set(i,pv);
return this;//返回原来的对象目的就是为了实现链式编程
}
}
propertyValuesList.add(pv);
return this;//返回原来的对象目的就是为了实现链式编程
}
//判断是否有指定name属性值的对象
public boolean contains(String propertyName) {
return getPropertyValue(propertyName) != null;
}
//获取迭代器对象
@Override
public Iterator<PropertyValue> iterator() {
return propertyValuesList.iterator();
}
}
接着我们提供获取所有的PropertyValue对象并以数组形式返回的方法，这里调用的就是数组中toArray方法，并且我们这里返回的是一个我们指定的数组对象
然后我们再提供一个根据name属性值获得具体的PropertyValue对象的方法，这里就是直接遍历集合然后比对名字即可
接着是判断集合是否为空，添加对象到集合中的方法。这里值得一提是，我们这里为了实现链式编程，所以这里每次添加时都令其返回当前的对象
其次是这里判断是否有指定name属性值的对象的时候调用了同层的另一个方法，我这当然也可以，但是我印象中是同层的方法是不可以互相调用的，这里可能存在不合乎规范的问题
BeanDefiniton类
BeanDefinition类用来封装bean信息的，主要包含id（即bean对象的名称）、class（需要交由spring管理的类的全类名）及子标签property数据
我们同样是将我们的类创建在beans包下，我们这里提供id和className属性，当然，其下还具有管理PropertyValue对象的MutablePropertyValues对象，我们提供了对应的getandset方法之后再提供一个无参的构造方法，无参的构造方法中，我们需要创建我们的管理对象
package com.itheima.framework.beans;
/**
* 用来封装bean标签属性
* id属性
* class属性
* property子标签的数据
*/
public class BeanDefinition {
private String id;
private String className;
private MutablePropertyValues propertyValues;
public BeanDefinition() {
this.propertyValues = new MutablePropertyValues();
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getClassName() {
return className;
}
public void setClassName(String className) {
this.className = className;
}
public MutablePropertyValues getPropertyValues() {
return propertyValues;
}
public void setPropertyValues(MutablePropertyValues propertyValues) {
this.propertyValues = propertyValues;
}
}
定义注册表相关类
BeanDefintionRgistry定义了注册表的相关操作并且定义了注册表的相关操作，具体拥有的功能请看下图
那么我们首先在beans下的factory的support包内创建BeanDefinitionRegistry接口
/**
* 注册表接口
*/
public interface BeanDefinitionRegistry {
//注册BeanDefinition对象到注册表中
void registerBeanDefinition(String beanName, BeanDefinition beanDefinition);
//从注册表中删除指定名称的BeanDefinition对象
void removeBeanDefinition(String beanName) throws Exception;
//根据名称从注册表中获取BeanDefinition对象
BeanDefinition getBeanDefinition(String beanName) throws Exception;
boolean containsBeanDefinition(String beanName);
int getBeanDefinitionCount();
String[] getBeanDefinitionNames();
}
然后创建其子实现类，该实现类内部拥有一个Map用于用于存储BeanDefiniton作为value值，而Stirng作为唯一标识
接着我们提供对应的方法即可，无非就是调用Map中的各种方法而已
public class SimpleBeanDefinitionRegistry implements BeanDefinitionRegistry{
//定义一个容器，用来存储BeanDefinition
private Map<String,BeanDefinition> beanDefinitionMap = new HashMap<>();
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) {
beanDefinitionMap.put(beanName,beanDefinition);
}
@Override
public void removeBeanDefinition(String beanName) throws Exception {
beanDefinitionMap.remove(beanName);
}
@Override
public BeanDefinition getBeanDefinition(String beanName) throws Exception {
return beanDefinitionMap.get(beanName);
}
@Override
public boolean containsBeanDefinition(String beanName) {
return beanDefinitionMap.containsKey(beanName);
}
@Override
public int getBeanDefinitionCount() {
return beanDefinitionMap.size();
}
@Override
public String[] getBeanDefinitionNames() {
return beanDefinitionMap.keySet().toArray(new String[0]);
}
}
最后都学习到这里了，为了防止我们搞混了，我们先来梳理下目前位置我们学习的内容之间的关系
我们都知道每一个property标签都会被封装成propertyValue对象，而且propertyValues对象会被MutableProperty管理，这个对象我们姑且成为property标签管理对象，然后的bean标签本身又具有id和class属性，这些是属性是封装到BeanDefinition对象中的，同时其下还具有标签管理对象的属性，相当于BeanDefiniton就代表了一个bean标签。然后我们还提供了一个类用来保存bean的唯一标识和其具体内容，该类就是BeanDefinitionRegistry类，其下具有一个Map属性，左边对应的用户给被管理类指定提供的唯一标识，右边则是代表了管理一个类的BeanDefiniton类，换言之，我们可以将BeanDefinitonRegistry简单理解为整个容器，其管理了我们托管到容器中的所有类
定义解析器相关类
接着我们要来定义解析器的相关类，即使解析配置文件并令其自动将配置文件的信息注册到我们的注册表中，这里我们一般使用先创建一个BeanDefinitonReader接口
接口中提供两个方法，一个是获取注册表对象，另外一个是加载配置文件并在注册表中进行注册
至于为什么我们不直接创建实现类而是创建一个接口，这是因为我们的解析器相关类是有多个实现类的，针对不同的配置有不同的实现方式，所以我们这里一般是是一个接口多个实现类的方式，当然我们这里是学习阶段，所以我们这里其实也只搞一个实现类就是了
XmlBeanDefinitionReader类是专门用来解析xml配置文件的。该类实现BeanDefinitionReader接口并实现接口中的两个功能，我们就创建这个类并实现其功能
首先我们要读取配置流我们需要借助到外部的dom4j工具，我们首先引入对应的依赖，dom4j的坐标如下
<dependency>
<groupId>dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>1.6.1</version>
</dependency>
那么最终我们可以写入我们的实现类的代码如下，首先我们实现类中组合了注册表对象的属性，第一个方法要获得当前的注册表对象，我们直接返回该对象即可，重点在于第二个方法的实现，我们这里能看到我们的类是一开始就有注册表对象的，这是当然的，因为我们的这个类要实现的事情就是将配置的内容自动注册到注册表中，要是我们这个类里一开始就没有注册表对象，那还自动注册个几把
/**
* 针对xml配置文件进行解析的类
*/
public class XmlBeanDefinitionReader implements BeanDefinitionReader {
//声明注册表对象
private BeanDefinitionRegistry registry;
public XmlBeanDefinitionReader() {
registry = new SimpleBeanDefinitionRegistry();
}
@Override
public BeanDefinitionRegistry getRegistry() {
return registry;
}
@Override
public void loadBeanDefinitions(String configLocation) throws Exception {
//使用dom4j进行xml配置文件的解析
SAXReader reader = new SAXReader();
//获取类路径下的配置文件
InputStream ois = XmlBeanDefinitionReader.class.getClassLoader().getResourceAsStream(configLocation);
Document document = reader.read(ois);
//根据Document对象获取根标签对象(beans)
Element rootElement = document.getRootElement();
//获取根标签下的所有bean标签对象
List<Element> beanElements = rootElement.elements("bean");
for (Element beanElement : beanElements) {
//获取id属性
String id = beanElement.attributeValue("id");
//获取class属性
String className = beanElement.attributeValue("class");
//将id属性和class属性封装到beanDefinition
//1.创建BeanDefinition
BeanDefinition beanDefinition = new BeanDefinition();
beanDefinition.setId(id);
beanDefinition.setClassName(className);
//创建MutablePropertyValues对象
MutablePropertyValues mutablePropertyValues = new MutablePropertyValues();
//获取bean标签下所有的property标签对象
List<Element> propertyElements = beanElement.elements("property");
for (Element propertyElement : propertyElements) {
String name = propertyElement.attributeValue("name");
String ref = propertyElement.attributeValue("ref");
String value = propertyElement.attributeValue("value");
PropertyValue propertyValue = new PropertyValue(name,ref,value);
mutablePropertyValues.addPropertyValue(propertyValue);
}
//将MutablePropertyValues对象封装到BeanDefinition对象中
beanDefinition.setPropertyValues(mutablePropertyValues);
//将beanDefinition对注册到注册表中
registry.registerBeanDefinition(id,beanDefinition);
}
}
}
首先我们使用dom4j，创建对应的SAXReader对象，然后蝴蝶传入的类路径下的配置文件得到其输入流，然后传入到dom4j中可以获取到Document对象，我们可以根据Document对象获取根标签对象beans，调用内部的getRootElement()方法即可，得到的是一个大的beans标签
然后我们调用Element内部的elements方法，传入bean关键字，就可以获得其下所有的bean标签对象，我们用集合承接
接着我们遍历所有的bean标签，获得bean标签内部的id和classname属性，接着我们创建BeanDefinition对象，相当于是我们创建了一个代表bean标签的类，将对应的id和classname都设置到该对象中，接着创建管理bean内的所有property尚需经的管理者对象MutablePropertyValues对象，然后我们获取bean标签下的所有property标签对象
继续遍历该集合，获取其中的name，ref和value属性值，然后创建一个PropertyValue对象并设置对应的属性，其代表了封装一个property属性，然后往管理者对象中添加该对象
这个过程设置完后再往代表整个bean标签的BeanDefiniton对象中设置我们的property管理者对象进去，最后每次循环末位我们都将代表bean标签的对象和唯一标识加入到我们的注册表中
经过这一整个过程，最终我们就实现了我们的注册表的自动注册
值得一提的是，我们这里只是实现了自动注册而已，也就是说我们的注册表BeanDefinitionRegistry对象中已经有我们之前保存的对应的数据了，但是实际的对象还不存在，创建实际对象的方法在IOC容器相关类中实现，并不是这里
那有人会说注册表有个什么几把用？其实注册表存在的意义就是知道后面的IOC到底要创建哪些类到容器中而存在的
IOC容器相关类
接着我们我们来定义我们的容器相关的类，这也是我们的本次学习最核心的内容，首先我们要定义BeanFactory接口，该接口中定义了IOC容器获取Bean对象的统一规范
/**
* IOC容器父接口
*/
public interface BeanFactory {
Object getBean(String name) throws Exception;
<T> T getBean(String name,Class<? extends T> clazz) throws Exception;
}
我们第二个方法是使用了泛型，其代表的意义是我们返回的类型是一个传入的泛型，而传入的参数只需要是该泛型或者是该泛型的子实现类即可
然后我们来看看ApplicaitonContext接口
那么根据上图我们可以定义该接口如下
/**
* 定义非延时加载功能
*/
public interface ApplicationContext extends BeanFactory {
void refresh() throws Exception;
}
接着我们来创造其具体的实现类，先来看看构造该类应该注意的事项
那么最终我们可以构造我们的代码如下，首先其实现了ApplicationContext接口，其下首先声明了解析器的变量、存储对象的容器以及文件路径的属性
/**
* AbstractApplicationContext接口的子实现类，用于立即加载
*/
public abstract class AbstractApplicationContext implements ApplicationContext {
//声明解析器变量
protected BeanDefinitionReader beanDefinitionReader;
//定义用于存储bean对象的map容器
protected Map<String,Object> singletonObjects = new HashMap<>();
//声明配置文件路径的变量
protected String configLocation;
@Override
public void refresh() throws Exception {
//加载BeanDefinition对象
beanDefinitionReader.loadBeanDefinitions(configLocation);
//初始化bean
finishBeanInitialization();
}
//bean的初始化
protected void finishBeanInitialization() throws Exception {
//获取注册表对象
BeanDefinitionRegistry registry = beanDefinitionReader.getRegistry();
//获取BeanDefinition对象
String[] beanNames = registry.getBeanDefinitionNames();
for (String beanName : beanNames) {
BeanDefinition beanDefinition = registry.getBeanDefinition(beanName);
//初始化bean
getBean(beanName);
}
}
}
首先重写的当然是refresh方法，该方法内我们要加载beanDefiniton对象，我们直接调用其下的自动注册方法，将对应的配置文件的路径传入即可实现将类自动装配到我们的容器中，然后我们调用初始化bean的方法
提供bean的初始化方法，首先获取到我们的注册表对象，然后获取其中的所有BeanDefiniton对象，接着通过BeanFactory的getBean方法实现对注册的类的初始化，当然，目前这个方法还没创建出来，因为我们这个类还只是抽象类，实现具体的初始化方法还需要靠更下一级的子类来实现，因为只有子类明确到底创建BeanDefinitionReader哪个子实现类对象。
ClassPathXmlApplicationContext类
现在我们来学其真正的具体实现类，首先我们来看看其要完成的功能
为了便于我们后续的操作，我们首先构造一个工具类，该工具类可以将传入的方法进行分割，最终返回我们所需要的set方法类型的字符串，便于我们需要完成的依赖注入操作
public class StringUtils {
private StringUtils() {
}
//userDao ==> setUserDao
public static String getSetterMethodByFieldName(String fieldName){
String methodName = "set" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
return methodName;
}
}
那么最终我们可以构造我们的具体实现类如下，其继承了之前的抽象类，必须要重写获取bean对象的方法，这个我们先按下不表
我先来说说其最开始的构造方法，我们往其中提供了一个构造方法，使用该构造方法必须要传入一个对应的类路径地址，我们会将该地址赋予到类属性的保存地址的属性中，我们在构造方法中会构建一个解析器对象，这就相当于是给我们类中最开始的解析器对象赋值，便于我们后续的使用
然后我们再调用该类中的refresh方法，让我们的注册表自动注入对应的配置信息
/**
* IOC容器具体的子实现类
* 用于加载类路径下的xml格式的配置文件文件
*/
public class ClassPathXmlApplicationContext extends AbstractApplicationContext{
public ClassPathXmlApplicationContext(String configLocation) {
this.configLocation=configLocation;
//构建解析器对象
beanDefinitionReader = new XmlBeanDefinitionReader();
try {
this.refresh();
}catch (Exception e){
e.printStackTrace();
}
}
//根据bean对象的名称获取bean对象
@Override
public Object getBean(String name) throws Exception {
//判断对象容器中是否包含指定名称的bean对象，若包含则返回，反之则创建
Object obj = singletonObjects.get(name);
if(obj!=null){
return obj;
}
//获取BeanDefinition对象
BeanDefinitionRegistry registry = beanDefinitionReader.getRegistry();
BeanDefinition beanDefinition = registry.getBeanDefinition(name);
if(beanDefinition == null) {
return null;
}
//获取bean信息中的className
String className = beanDefinition.getClassName();
//通过反射创建对象
Class<?> clazz = Class.forName(className);
Object beanObj = clazz.newInstance();
//进行依赖注入操作
MutablePropertyValues propertyValues = beanDefinition.getPropertyValues();
for (PropertyValue propertyValue : propertyValues) {
//获取name属性值
String propertyName = propertyValue.getName();
//获取value属性
String value = propertyValue.getValue();
//获取ref属性
String ref = propertyValue.getRef();
if(ref != null && !"".equals(ref)){
//获取依赖的bean对象
Object bean = getBean(ref);
//拼接方法名
String methodName = StringUtils.getSetterMethodByFieldName(propertyName);
//获取所有的方法对象
Method[] methods = clazz.getMethods();
for (Method method : methods) {
if(methodName.equals(method.getName())){
//执行该setter方法
method.invoke(beanObj,bean);
}
}
}
if(value!=null && !"".equals(value)){
//拼接方法名
String methodName = StringUtils.getSetterMethodByFieldName(propertyName);
//获取method对象
Method method = clazz.getMethod(methodName, String.class);
method.invoke(beanObj,value);
}
}
//在返回beanObj对象之前，将对象存储到map容器中
singletonObjects.put(name,beanObj);
return beanObj;
}
@Override
public <T> T getBean(String name, Class<? extends T> clazz) throws Exception {
Object bean = getBean(name);
if(bean==null){
return null;
}
return clazz.cast(bean);
}
}
接着比较重量级的是就是第一个根据bean对象名称获取bean对象的方法了，首先我们判断我们的容器中是否存在指定名称的bean对象，若不存在我们再创建
要创建我们当然首先要获取到我们的注册表对象，调用容器中的getRegistry即可获取到我们的注册表对象，然后再调用获得具体Bean对象的方法并传入关键字即可获得代表一个bean标签的BeanDefinition对象，然后我们再做一个判断，如果我们的bean对象居然都是空的，那就直接传回空对象即可
然后获取bean信息中的classname，我们通过反射方式来创建对象，这个很好理解，但是接下来的问题在于，我们的创建的这个对象可能依赖了其他的对象，此时就需要进行依赖注入，所以接下来我们需要机械能依赖注入操作
首先如果其需要进行对应的依赖注入操作，必然在配置类中是有对应的配置设置的，所以我们首先获得bean对象中的property管理者对象，然后对其进行比那里，获得其下的三个属性值，首先要判断的是ref是否为空，若为空就根本不需要处理，因为ref代表的是某个具体类的类路径，如果这都没有的话那肯定就是没什么需要注入了的
当其不为空时，我们递归继续获得其依赖的bean对象，相当于是我们进入其子类中再进行子类的创建，创建好子类之后就获得子类返回的bean对象，然后我们调用我们之前的工具类获得我们拼接的方法名，然后再通过class字节码属性获得其所有方法，将方法名与我们构造的方法名进行比对，如果一样则说明其就是我们所需要的设置依赖进入到对应类中的方法，那么我们就执行该方法即可
最后我们还有一个情况要考虑，就是我们的value值可能不为空，若value值不为空则说明我们的value值是有数据的，这些数据应该要被赋予到对应的属性中，所以当value值不为空时，我们就要进行对应的赋值操作，我们同样先进行方法名的拼接，然后获取到对应的方法对象，接着执行对应的set方法，当然，使用反射的方式
最后我们在返回对应的beanObj对象之前，我们需要将对象存储到我们的mpa容器中，不然我们的东西光创建出来不保存也的确也没啥用不是
然后第二个方法是根据名字和类别来获得对应的bean对象，这里我们直接调用上一个方法得到的结果即可，如果不为空则说明的确有这个方法，我们就令该对象强制转换再返回即可
功能测试
接着我们来测试下我们的自定义的Spring框架到底有没有用，我们首先将该项目编译安装，然后在对应的pom文件中引入我们的坐标重新运行即可，最后得到的结果是确实可行的
然后我们再给我们UserDaoImpl中加入两个String变量，提供对应的set方法，为了看到效果，我们还往展示的方法中也一并展示这两个数据
public class UserDaoImpl implements UserDao {
private String username;
private String password;
public void setUsername(String username) {
this.username = username;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public void add() {
System.out.println("UserDao..."+username+"=="+password);
}
}
然后我们往配置类中进行更加具体的配置，可以看到我们这里就是按照我们之前的规则进行的配置而已，即使是在Spring中也是如此配置的
<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
<property name="userDao" ref="userDao"></property>
</bean>
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">
<property name="username" value="zhangsan"></property>
<property name="password" value="123456"></property>
</bean>
</beans>
然后我们重新测试，发现控制台上的确打印了我们需要的东西，那我们的框架就是没有问题的
自定义Spring IOC总结
最后我们来看看其总结
