# factorydemo

**Repository Path**: coder-msc/factorydemo

## Basic Information

- **Project Name**: factorydemo
- **Description**: 策略+工厂简单实战应用
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2022-09-07
- **Last Updated**: 2022-09-08

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

## 策略模式+工厂模式   的简单实战应用

#### 屁话少说 直接上代码，自己跑一下就知道了
```java
https://gitee.com/coder-msc/factorydemo
```
#### 1、创建几个基础类
B.java
```java
@Data
public class B {
    private String bb;
}
```
A.java
```java
@Data
public class A extends B {
    private String aa;
//    private String bb; //放到父类中
}
```
C.java
```java
@Data
public class C extends B {
    private String cc;
//    private String bb; //放到父类中
}
```

#### 2、策略模式开始 创建抽象类
BaseControl.java
```java
public abstract class BaseControl<T> {

    protected int variantFormId;

    //（容器中需要确保能唯一区分）
    public void setVariantFormId(int variantFormId) {
        this.variantFormId = variantFormId;
    }

    public int getVariantFormId() {
        return variantFormId;
    }

    //详情查询
    public abstract T queryVariant(String value);

    public void updateTest(B b) {
        System.out.println("更新B对象"+b.getBb());
        //update B 类
    }

    protected T getVariantT(B b) {
        return (T) b;
    }
}
```
#### 路由对象之 ---需要集成抽象类的子类AControl
AControl.java

```java
@Component
public class AControl extends BaseControl<A> {

    //构造方法初始化key值，为了满足策略模式中的工厂赋值 方便找到
    public AControl() {
        this.variantFormId = 1; //设置key值 （容器中需要确保能唯一区分）
    }

    @Override
    public A queryVariant(String value) {
        System.out.println("传入的值:"+value);
        A a = new A();
        a.setAa("a里的aa值");
        a.setBb("a里的bb值");
        return a;
    }

    public void updateTest(B b) {
        super.updateTest(b); // 父类方法不会调用，若要执行，需要使用supper显示调用
        A a = getVariantT(b);
        System.out.println("更新A对象aa"+a.getAa());
        System.out.println("更新A对象bb"+a.getBb());
        //update A 类
    }
}

```

#### 路由对象之 --- 需要集成抽象类的子类CControl

CControl.java

```java
@Component
public class CControl extends BaseControl<C> {
    //为了满足策略模式中的工厂赋值 方便找到
    public CControl() {
        this.variantFormId = 3; //设置key值（容器中需要确保能唯一区分）
    }

    @Override
    public C queryVariant(String value) {
        System.out.println("传入的值:" + value);
        C c = new C();
        c.setCc("c里的cc值");
        c.setBb("c里的bb值");
        return c;
    }

    public void updateTest(B b) {
        C c = getVariantT(b); //B类转C类 仍能找到cc值
        System.out.println("更新C对象cc" + c.getCc());
        System.out.println("更新C对象bb" + c.getBb());
        //update C 类
    }
}
```

#### 工厂的创建，路由策略制定
MyStrategyRoute.java
```java
@Component
public class MyStrategyRoute {
    @Resource
    private ApplicationContext applicationContext;
    private Map<Integer, BaseControl> beansMap = new HashMap<>(); //容器启动的时候，把bean放到Map中
    private Optional<BaseControl> defaultBeans;

    @PostConstruct
    public void postConstruct() {
        Map<String, BaseControl> map = applicationContext.getBeansOfType(BaseControl.class); // 获取容器中的实列（对象）
        if (map != null) {
            beansMap = map.values().stream().collect(Collectors.toMap(BaseControl::getVariantFormId, Function.identity(), (k1, k2) -> k1));
            defaultBeans = map.values().stream().findFirst();
        }
    }

    public Optional<BaseControl> getVariantControl(Integer variantFormId) {
        return Optional.ofNullable(beansMap.get(variantFormId));
    }

    public Optional<BaseControl> getDefaultVariantControl() {
        return defaultBeans;
    }
}
```

#### 测试效果
myTest.java
```java
@RestController
@RequestMapping(value = "/mytest")
public class myTest {
    @Autowired
    private MyStrategyRoute myStrategyRoute;

    @RequestMapping("/test")
    public void test() {
        Optional<BaseControl> optional = myStrategyRoute.getVariantControl(1); //找到的是AControl
        B b = null;
        if (optional.isPresent()) {
            b = (B) optional.get().queryVariant("我在哪里打印了？"); // 可以统一用B 来接  因为 1 和3 都继承了 B类
//            b.getAa(); 有Aa的值 但是取不出来的 需要强转
        }
        // 上一步查询到的是A类的详情，传递的是引用，虽然B类没有aa这个字段，当B转换成A的时候  仍然能获取到aa
//        A a = (A) b;  // 需要注意 A和C都继承了B  但是A和C互转 会出现异常
//        System.out.println(a.getBb());
//        System.out.println(a.getAa());

        // 更新对象
        // 传入的是个B对象 但是带着A对象（或C对象）的属性 ，因此可以更新A（或C）的所有属性
        // 如果要更新B对象  需要使用supper显示调用，见A的方法
        optional.get().updateTest(b);
    }
}

```