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

╰+哭是因爲堅強的太久メ 2024-03-23 20:20 47阅读 0赞

>     package com.powernode.factory.method;
>     
>     public class Test
>     {
>         public static void main(String[] args)
>         {
>             //每增加一个商品,都需要增加一个具体类和对象实现工厂,使得系统中类的个数成倍增加
>             //增加了系统复杂度,增加了系统具体类的依赖
>             WeaponFactory DaggerFactory = FactoryMode.get("DaggerFactory");
>             Weapon Dagger = DaggerFactory.get();
>             Dagger.attack();
>     
>             WeaponFactory GunFactory = FactoryMode.get("GunFactory");
>             Weapon Gun = GunFactory.get();
>             Gun.attack();
>         }
>     }
> 
> package com.powernode.factory.method;  
>   
> public class Test  
> \{  
> public static void main(String\[\] args)  
> \{  
> //每增加一个商品,都需要增加一个具体类和对象实现工厂,使得系统中类的个数成倍增加  
> //增加了系统复杂度,增加了系统具体类的依赖  
> WeaponFactory DaggerFactory = FactoryMode.get("DaggerFactory");  
> Weapon Dagger = DaggerFactory.get();  
> Dagger.attack();  
>   
> WeaponFactory GunFactory = FactoryMode.get("GunFactory");  
> Weapon Gun = GunFactory.get();  
> Gun.attack();  
> \}  
> \}

>     package com.powernode.factory.method;
>     
>     public abstract class Weapon
>     {
>         //当添加新的产品时,只需要添加具体产品类和具体工厂类,都是添加类,没有修改原来的代码,符合OCP原则
>         //抽象产品角色
>         public abstract void attack();
>     }
> 
> package com.powernode.factory.method;  
>   
> public abstract class Weapon  
> \{  
> //当添加新的产品时,只需要添加具体产品类和具体工厂类,都是添加类,没有修改原来的代码,符合OCP原则  
> //抽象产品角色  
> public abstract void attack();  
> \}

>     package com.powernode.factory.method;
>     
>     public class GunFactory extends WeaponFactory
>     {
>         //具体工厂角色
>         @Override
>         public Weapon get()
>         {
>             return new Gun();
>         }
>     }
> 
> package com.powernode.factory.method;  
>   
> public class GunFactory extends WeaponFactory  
> \{  
> //具体工厂角色  
> @Override  
> public Weapon get()  
> \{  
> return new Gun();  
> \}  
> \}

>     package com.powernode.factory.method;
>     
>     public class DaggerFactory extends WeaponFactory
>     {
>         //不需要传参了
>         @Override
>         public Weapon get()
>         {
>             return new Dagger();
>         }
>     }
> 
> package com.powernode.factory.method;  
>   
> public class DaggerFactory extends WeaponFactory  
> \{  
> //不需要传参了  
> @Override  
> public Weapon get()  
> \{  
> return new Dagger();  
> \}  
> \}

>     package com.powernode.factory.method;
>     
>     import java.lang.reflect.Constructor;
>     
>     public class FactoryMode
>     {
>         //静态方法,要获取什么产品就看传入参数,传什么就返回什么
>         //简单工厂模式有一个静态方法,所以也被称为静态工厂模式,工厂模式的特点,方法是静态的不是实例的,通过传参的方式创建对象
>         public static WeaponFactory get(String FactoryName)
>         {
>             WeaponFactory weaponFactory = null;
>             try
>             {
>                 Constructor constructor = Class.forName(FactoryName).getDeclaredConstructor();
>                 weaponFactory = (WeaponFactory)constructor.newInstance();
>             }
>             catch (Exception e)
>             {
>                 throw new RuntimeException(e);
>             }
>             return weaponFactory;
>         }
>     }
> 
> package com.powernode.factory.method;  
>   
> import java.lang.reflect.Constructor;  
>   
> public class FactoryMode  
> \{  
> //静态方法,要获取什么产品就看传入参数,传什么就返回什么  
> //简单工厂模式有一个静态方法,所以也被称为静态工厂模式,工厂模式的特点,方法是静态的不是实例的,通过传参的方式创建对象  
> public static WeaponFactory get(String FactoryName)  
> \{  
> WeaponFactory weaponFactory = null;  
> try  
> \{  
> Constructor constructor = Class.forName(FactoryName).getDeclaredConstructor();  
> weaponFactory = (WeaponFactory)constructor.newInstance();  
> \}  
> catch (Exception e)  
> \{  
> throw new RuntimeException(e);  
> \}  
> return weaponFactory;  
> \}  
> \}

>     package com.powernode.factory.method;
>     
>     abstract public class WeaponFactory
>     {
>         //这个方法不是静态的,是实例方法
>         //工厂方法模式可以解决简单工厂模式中的OCP问题,一个工厂对应一个产品,这样工厂就不是全能类了,符合了OCP原则
>         public abstract Weapon get();
>     }
> 
> package com.powernode.factory.method;  
>   
> abstract public class WeaponFactory  
> \{  
> //这个方法不是静态的,是实例方法  
> //工厂方法模式可以解决简单工厂模式中的OCP问题,一个工厂对应一个产品,这样工厂就不是全能类了,符合了OCP原则  
> public abstract Weapon get();  
> \}

>     package com.powernode.factory.method;
>     
>     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.factory.method;  
>   
> 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.factory.method;
>     
>     import org.slf4j.Logger;
>     import org.slf4j.LoggerFactory;
>     
>     public class Gun extends Weapon
>     {
>         //具体产品角色
>         private Logger logger = LoggerFactory.getLogger(Gun.class);
>         @Override
>         public void attack()
>         {
>             logger.info("开枪射击");
>         }
>     }
> 
> package com.powernode.factory.method;  
>   
> import org.slf4j.Logger;  
> import org.slf4j.LoggerFactory;  
>   
> public class Gun extends Weapon  
> \{  
> //具体产品角色  
> private Logger logger = LoggerFactory.getLogger(Gun.class);  
> @Override  
> public void attack()  
> \{  
> logger.info("开枪射击");  
> \}  
> \}