Spring的原理基础之工厂模式的简单工厂模式详解-----Spring框架

逃离我推掉我的手 2024-03-23 20:15 27阅读 0赞

> ###  ###
> 
>     package com.powernode.simple.factory;
>     
>     public abstract class Weapon
>     {
>         //抽象产品角色,所有的武器都有攻击能力
>         //简单工厂又被称为静态工厂方法模式,客户端不需要关心对象的具体创建细节,需要哪个对象直接向工厂索要即可
>         //初步实现了责任的分离,客户端只负责消费,工厂负责生产,生产与消费分离
>         //简单工厂模式的角色:抽象产品,具体产品,工厂类角色
>         //简单工厂模式的缺点,拓展力不足,WeaponFactory代码需要修改,违背了OCP原则,工厂类的责任比较重大,不能出现任何问题
>         //这个工厂类一旦出现问题,整个系统必然全部出错
>         public abstract void attack();
>     }
> 
> package com.powernode.simple.factory;  
>   
> public abstract class Weapon  
> \{  
> //抽象产品角色,所有的武器都有攻击能力  
> //简单工厂又被称为静态工厂方法模式,客户端不需要关心对象的具体创建细节,需要哪个对象直接向工厂索要即可  
> //初步实现了责任的分离,客户端只负责消费,工厂负责生产,生产与消费分离  
> //简单工厂模式的角色:抽象产品,具体产品,工厂类角色  
> //简单工厂模式的缺点,拓展力不足,WeaponFactory代码需要修改,违背了OCP原则,工厂类的责任比较重大,不能出现任何问题  
> //这个工厂类一旦出现问题,整个系统必然全部出错  
> public abstract void attack();  
> \}

>     package com.powernode.simple.factory;
>     //工厂类角色
>     public class WeaponFactory
>     {
>     
>         //静态方法,要获取什么产品就看传入参数,传什么就返回什么
>         //简单工厂模式有一个静态方法,所以也被称为静态工厂模式,工厂模式的特点,方法是静态的不是实例的,通过传参的方式创建对象
>         public static Weapon get(String weaponName)
>         {
>             if("TANK".equals(weaponName))
>             {
>                 return new Tank();
>             }
>             else if("DAGGER".equals(weaponName))
>             {
>                 return new Dagger();
>             }
>             else if("FIGHTER".equals(weaponName))
>             {
>                 return new Fighter();
>             }
>             else
>             {
>                 throw new RuntimeException("不支持该武器生产");
>             }
>         }
>     }
> 
> package com.powernode.simple.factory;  
> //工厂类角色  
> public class WeaponFactory  
> \{  
>   
> //静态方法,要获取什么产品就看传入参数,传什么就返回什么  
> //简单工厂模式有一个静态方法,所以也被称为静态工厂模式,工厂模式的特点,方法是静态的不是实例的,通过传参的方式创建对象  
> public static Weapon get(String weaponName)  
> \{  
> if("TANK".equals(weaponName))  
> \{  
> return new Tank();  
> \}  
> else if("DAGGER".equals(weaponName))  
> \{  
> return new Dagger();  
> \}  
> else if("FIGHTER".equals(weaponName))  
> \{  
> return new Fighter();  
> \}  
> else  
> \{  
> throw new RuntimeException("不支持该武器生产");  
> \}  
> \}  
> \}

>     package com.powernode.simple.factory;
>     
>     public class Test
>     {
>         public static void main(String[] args)
>         {
>             //对于我客户端来说,对象的产生我不关心,我只需要向工厂索要即可,简单工厂模式达到了职责分离,客户端不需要关心产品的生产细节,一个负责生产,一个负责销售
>             //需要坦克
>             Weapon Tank = WeaponFactory.get("TANK");
>             Tank.attack();
>             //需要匕首
>             Weapon Dagger = WeaponFactory.get("DAGGER");
>             Dagger.attack();
>             //需要战斗机
>             Weapon Fighter = WeaponFactory.get("FIGHTER");
>             Fighter.attack();
>             //如果不用抽象工厂模式就需要关心对象的抽象细节
>             //如Weapon tank = new Tank();
>         }
>     }
> 
> package com.powernode.simple.factory;  
>   
> public class Test  
> \{  
> public static void main(String\[\] args)  
> \{  
> //对于我客户端来说,对象的产生我不关心,我只需要向工厂索要即可,简单工厂模式达到了职责分离,客户端不需要关心产品的生产细节,一个负责生产,一个负责销售  
> //需要坦克  
> Weapon Tank = WeaponFactory.get("TANK");  
> Tank.attack();  
> //需要匕首  
> Weapon Dagger = WeaponFactory.get("DAGGER");  
> Dagger.attack();  
> //需要战斗机  
> Weapon Fighter = WeaponFactory.get("FIGHTER");  
> Fighter.attack();  
> //如果不用抽象工厂模式就需要关心对象的抽象细节  
> //如Weapon tank = new Tank();  
> \}  
> \}

>     package com.powernode.simple.factory;
>     
>     import org.slf4j.Logger;
>     import org.slf4j.LoggerFactory;
>     
>     public class Tank extends Weapon
>     {
>         private Logger logger = LoggerFactory.getLogger(Tank.class);
>         @Override
>         public void attack()
>         {
>             logger.info("坦克开炮");
>         }
>     }
> 
> package com.powernode.simple.factory;  
>   
> import org.slf4j.Logger;  
> import org.slf4j.LoggerFactory;  
>   
> public class Tank extends Weapon  
> \{  
> private Logger logger = LoggerFactory.getLogger(Tank.class);  
> @Override  
> public void attack()  
> \{  
> logger.info("坦克开炮");  
> \}  
> \}

>     package com.powernode.simple.factory;
>     
>     import org.slf4j.Logger;
>     import org.slf4j.LoggerFactory;
>     
>     public class Fighter extends Weapon
>     {
>         private Logger logger = LoggerFactory.getLogger(Fighter.class);
>         @Override
>         public void attack()
>         {
>             logger.info("飞机扔下小男孩");
>         }
>     }
> 
> package com.powernode.simple.factory;  
>   
> import org.slf4j.Logger;  
> import org.slf4j.LoggerFactory;  
>   
> public class Fighter extends Weapon  
> \{  
> private Logger logger = LoggerFactory.getLogger(Fighter.class);  
> @Override  
> public void attack()  
> \{  
> logger.info("飞机扔下小男孩");  
> \}  
> \}

>     package com.powernode.simple.factory;
>     
>     import org.slf4j.Logger;
>     import org.slf4j.LoggerFactory;
>     
>     public class Dagger extends Weapon
>     {
>         private Logger logger = LoggerFactory.getLogger(Dagger.class);
>         @Override
>         public void attack()
>         {
>             logger.info("砍丫的");
>         }
>     }
> 
> package com.powernode.simple.factory;  
>   
> import org.slf4j.Logger;  
> import org.slf4j.LoggerFactory;  
>   
> public class Dagger extends Weapon  
> \{  
> private Logger logger = LoggerFactory.getLogger(Dagger.class);  
> @Override  
> public void attack()  
> \{  
> logger.info("砍丫的");  
> \}  
> \}