• 08 创建型模式-工厂模式

    1.定义

    在这里插入图片描述

    2.案例场景

    为了让我们的案例更加贴近实际开发, 这里我们来模拟一下互联网电商中
    促销拉新下的业务场景, 新用户注册立即参与抽奖活动 ,奖品的种类有: 打折券,
    免费优酷会员,小礼品
    在这里插入图片描述
    (1)不考虑设计原则,不使用设计模式的方式进行开发,代码如下：
    在这里插入图片描述

    import java.util.Map;

/**
 * 获奖信息实体类
 **/
public class AwardInfo {

    private String uid; //用户id

    private Integer awardTypes; //奖品类型: 1 打折券 ,2 优酷会员 , 3 小礼品

    private String awardNumber; //奖品编号

    private Map<String,String> extMap; //额外信息

    public AwardInfo() {
    }

    @Override
    public String toString() {
        return "AwardInfo{" +
                "uid='" + uid + '\'' +
                ", awardTypes=" + awardTypes +
                ", awardNumber='" + awardNumber + '\'' +
                ", extMap=" + extMap +
                '}';
    }

    public String getUid() {
        return uid;
    }

    public void setUid(String uid) {
        this.uid = uid;
    }

    public Integer getAwardTypes() {
        return awardTypes;
    }

    public void setAwardTypes(Integer awardTypes) {
        this.awardTypes = awardTypes;
    }

    public String getAwardNumber() {
        return awardNumber;
    }

    public void setAwardNumber(String awardNumber) {
        this.awardNumber = awardNumber;
    }

    public Map<String, String> getExtMap() {
        return extMap;
    }

    public void setExtMap(Map<String, String> extMap) {
        this.extMap = extMap;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    /**
 * 打折券信息实体类
 **/
public class DiscountInfo {

    //属性信息省略......
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    /**
 * 优酷会员实体类
 **/
public class YouKuMember {

    //属性信息省略

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    /**
 * 小礼品实体类
 **/
public class SmallGiftInfo {

    private String userName;

    private String userPhone;

    private String orderId;

    private String address;

    @Override
    public String toString() {
        return "SmallGiftInfo{" +
                "userName='" + userName + '\'' +
                ", userPhone='" + userPhone + '\'' +
                ", orderId='" + orderId + '\'' +
                ", address='" + address + '\'' +
                '}';
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getUserPhone() {
        return userPhone;
    }

    public void setUserPhone(String userPhone) {
        this.userPhone = userPhone;
    }

    public String getOrderId() {
        return orderId;
    }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    
/**
 * 打折券响应信息封装实体类
 **/
public class DiscountResult {

    private String status; //状态码

    private String message; //信息


    public DiscountResult(String status, String message) {
        this.status = status;
        this.message = message;
    }

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    2)服务层:

    在这里插入图片描述

    /**
 * 打折券服务
 **/
public class DiscountService {

    public DiscountResult sendDiscount(String uid, String awardNumber){

        System.out.println("向用户发送一张打折券: " + uid +  " , " + awardNumber);
        return new DiscountResult("200","发放打折券成功!");
    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    /**
 * 小礼品服务
 **/
public class SmallGiftService {

    public Boolean giveSmallGift(SmallGiftInfo smallGiftInfo){

        System.out.println("小礼品已发送,获奖用户注意查收! " + JSON.toJSON(smallGiftInfo));
        return true;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    /**
 * 优酷会员
 **/
public class YouKuMemberService {

    public void openMember(String bindMobile, String awardNumber){

        System.out.println("发放优酷会员: " + bindMobile + " , " + awardNumber);
    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    3) 控制层

    在这里插入图片描述

    /**
 * 发放奖品接口
 **/
public class DeliverController {

    /**
     * 按照类型的不同发放奖品
     *      奖品类型: 1 打折券 ,2 优酷会员 , 3 小礼品, 4 优惠券
     * @param awardInfo
     */
    public void awardToUser(AwardInfo awardInfo){

        if(awardInfo.getAwardTypes() == 1){ //打折券
            DiscountService discountService = new DiscountService();
            DiscountResult discountResult = discountService.sendDiscount(awardInfo.getUid(), awardInfo.getAwardNumber());
            System.out.println("打折券发放成功!" + discountResult );

        }else if(awardInfo.getAwardTypes() == 2){//优酷会员

            String phone = awardInfo.getExtMap().get("phone");

            YouKuMemberService youKuMemberService = new YouKuMemberService();
            youKuMemberService.openMember(phone,awardInfo.getAwardNumber());
            System.out.println("优酷会员发放成功!");

        } else if(awardInfo.getAwardTypes() == 3){//小礼品
            //封装收获人信息
            SmallGiftInfo info = new SmallGiftInfo();
            info.setUserPhone(awardInfo.getExtMap().get("phone"));
            info.setUserName(awardInfo.getExtMap().get("username"));
            info.setAddress(awardInfo.getExtMap().get("address"));
            info.setOrderId(UUID.randomUUID().toString());

            SmallGiftService smallGiftService = new SmallGiftService();
            Boolean aBoolean = smallGiftService.giveSmallGift(info);
            if(aBoolean){
                System.out.println("小礼品发放成功!");
            }
        }

    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    4) 测试

    通过单元测试,来对上面的接口进行测试,验证代码质量

    public class TestApi01 {

    DeliverController deliverController = new DeliverController();

    //测试发放奖品接口
    @Test
    public void test01(){

        //1. 发放打折券优惠
        AwardInfo info1 = new AwardInfo();
        info1.setUid("1001");
        info1.setAwardTypes(1);
        info1.setAwardNumber("DEL12345");

        deliverController.awardToUser(info1);

    }

    @Test
    public void test02(){
        //2. 发放优酷会员
        AwardInfo info2 = new AwardInfo();
        info2.setUid("1002");
        info2.setAwardTypes(2);
        info2.setAwardNumber("DW12345");
        Map<String,String> map = new HashMap<>();
        map.put("phone","13512341234");
        info2.setExtMap(map);

        deliverController.awardToUser(info2);
    }

    @Test
    public void test03(){
        //2. 发放小礼品
        AwardInfo info3 = new AwardInfo();
        info3.setUid("1003");
        info3.setAwardTypes(3);
        info3.setAwardNumber("SM12345");
        Map<String,String> map2 = new HashMap<>();
        map2.put("username","大远");
        map2.put("phone","13512341234");
        map2.put("address","北京天安门");
        info3.setExtMap(map2);

        deliverController.awardToUser(info3);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48

    对于上面的实现方式,如果我们有想要添加的新的奖品时,势必要改动
    DeliverController的代码,违反开闭原则.而且如果有的抽奖接口出现问题,那么对
    其进行重构的成本会非常高.
    除此之外代码中有一组if分支判断逻辑,现在看起来还可以,但是如果经历几次迭
    代和拓展,后续ifelse肯定还会增加.到时候接手这段代码的研发将会十分痛苦.

    4.2.3 简单工厂模式

    简单工厂不是一种设计模式，反而比较像是一种编程习惯。简单工厂模式又叫做静态工厂方法模式（static Factory Method pattern）,它是通过使用静态方法接收不同的参数来返回不同的实例对象。
    在这里插入图片描述

    4.2.3.1 简单工厂原理

    在这里插入图片描述
    在这里插入图片描述

    4.2.3.3 简单工厂模式重构代码
    public interface IFreeGoods {
	ResponseResult sendFreeGoods(AwardInfo awardInfo);
}

    • 1
    • 2
    • 3
    工厂类
    /**
 * 具体工厂: 生成免费商品
 **/
public class FreeGoodsFactory {

    public static IFreeGoods getInstance(Integer awardType){

        IFreeGoods iFreeGoods = null;

        if(awardType == 1){  //打折券

            iFreeGoods = new DiscountFreeGoods();
        }else if(awardType == 2){ //优酷会员

            iFreeGoods = new YouKuMemberFreeGoods();
        }else if(awardType == 3){ //小礼品

            iFreeGoods = new SmallGiftFreeGoods();
        }
        return iFreeGoods;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    /**
 * 模拟打折券服务
 **/
public class DiscountFreeGoods implements IFreeGoods {

    @Override
    public ResponseResult sendFreeGoods(AwardInfo awardInfo) {

        System.out.println("向用户发放一张打折券: " + awardInfo.getUid() + " , " + awardInfo.getAwardNumber());
        return new ResponseResult("200","打折券发放成功!");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    /**
 * 小礼品发放服务
 **/
public class SmallGiftFreeGoods implements IFreeGoods {

    @Override
    public ResponseResult sendFreeGoods(AwardInfo awardInfo) {

        SmallGiftInfo smallGiftInfo = new SmallGiftInfo();
        smallGiftInfo.setUserPhone(awardInfo.getExtMap().get("phone"));
        smallGiftInfo.setUserName(awardInfo.getExtMap().get("username"));
        smallGiftInfo.setAddress(awardInfo.getExtMap().get("address"));
        smallGiftInfo.setOrderId(UUID.randomUUID().toString());

        System.out.println("小礼品发放成,请注意查收: " + JSON.toJSON(smallGiftInfo));
        return new ResponseResult("200","小礼品发送成功",smallGiftInfo);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    /**
 * 优酷 会员服务
 **/
public class YouKuMemberFreeGoods implements IFreeGoods {

    @Override
    public ResponseResult sendFreeGoods(AwardInfo awardInfo) {

        String phone = awardInfo.getExtMap().get("phone");
        System.out.println("发放优酷会员成功,绑定手机号: " + phone);
        return new ResponseResult("200","优酷会员发放成功!");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    4.2.3.4 简单工厂模式总结

    优点：封装了创建对象的过程，可以通过参数直接获取对象。把对象的创建和业务逻
    辑层分开，这样以后就避免了修改客户代码，如果要实现新产品直接修改工厂
    类，而不需要在原代码中修改，这样就降低了客户代码修改的可能性，更加容
    易扩展。
    缺点：增加新产品时还是需要修改工厂类的代码，违背了“开闭原则”。

    4.2.4 工厂方法模式

    概念: 定义一个用于创建对象的接口，让子类决定实例化哪个产品类对象。工厂
    方法使一个产品类的实例化延迟到其工厂的子类。

    4.2.4.2 工厂方法模式原理

    在这里插入图片描述
    在这里插入图片描述

    4.2.4.3 工厂方法模式重构代码

    为了提高代码扩展性,我们需要将简单工厂中的if分支逻辑去掉,通过增加抽象工厂(生产工厂的工厂)的方式,让具体工厂去进行实现,由具体工厂来决定实例化哪一个具体的产品对象。

    抽象工厂
    public interface FreeGoodsFactory {
	IFreeGoods getInstance();
}

    • 1
    • 2
    • 3

    具体工厂

    public class DiscountFreeGoodsFactory implements
FreeGoodsFactory {
	@Override
	public IFreeGoods getInstance() {
		return new DiscountFreeGoods();
	}
}
public class SmallGiftFreeGoodsFactory implements
FreeGoodsFactory {
	@Override
	public IFreeGoods getInstance() {
		return new SmallGiftFreeGoods();
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    Controller

    public class DeliverController {
/**
* 按照类型的不同发放商品
*/
	public ResponseResult awardToUser(AwardInfo awardInfo){
		FreeGoodsFactory freeGoodsFactory = null;
		if(awardInfo.getAwardType() == 1){
			freeGoodsFactory = new DiscountFreeGoodsFactory();
		}else if(awardInfo.getAwardType() == 2){
			freeGoodsFactory = new SmallGiftFreeGoodsFactory();
		}
		IFreeGoods freeGoods = freeGoodsFactory.getInstance();
		System.out.println("=====工厂方法模式========");
		ResponseResult result = freeGoods.sendFreeGoods(awardInfo);
		return result;
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    在这里插入图片描述

    /**
 * 工厂的工厂,用来创建工厂类对象.
 **/
public class FreeGoodsFactoryMap {

    //创建map集合,保存工厂对象
    private static final Map<Integer,FreeGoodsFactory> cachedFactories = new HashMap<>();

    static{
        cachedFactories.put(1,new DiscountFreeGoodsFactory());
        cachedFactories.put(2,new SmallGiftFreeGoodsFactory());
    }

    public static FreeGoodsFactory getParserFactory(Integer type){
        if(type == 1){

            FreeGoodsFactory freeGoodsFactory = cachedFactories.get(1);
            return freeGoodsFactory;
        }else if(type == 2){

            FreeGoodsFactory freeGoodsFactory = cachedFactories.get(2);
            return freeGoodsFactory;
        }

        return null;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    /**
 * 发放奖品接口
 **/
public class DeliverController {

    //发放奖品
    public ResponseResult awardToUser(AwardInfo awardInfo){

        //根据类型获取具体工厂
        FreeGoodsFactory goodsFactory = FreeGoodsFactoryMap.getParserFactory(awardInfo.getAwardTypes());

        //从工厂类中获取对应实例
        IFreeGoods iFreeGoods = goodsFactory.getInstance();

        System.out.println("==========工厂方法模式=============");
        ResponseResult responseResult = iFreeGoods.sendFreeGoods(awardInfo);
        return responseResult;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    现在我们的代码已经基本上符合了开闭原则,当有新增的产品时,我们需要做的事
    情包括:

    1. 创建新的产品类,并且让该产品实现抽象产品接口
    2. 创建产品类对应的具体工厂,并让具体工厂实现抽象工厂
    3. 将新的具体工厂对象,添加到FreeGoodsFactoryMap的cachedFactories中
      即可,需要改动的代码改动的非常少.
    4.2.4.4 工厂方法模式总结

    优点：
    (1)用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程；
    (2)在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无须对原工厂进行任何修改，满足开闭原则；
    缺点:
    每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度。

    什么时候使用工厂方法模式?

    (1)需要使用很多重复代码创建对象时，比如，DAO 层的数据对象、API 层的VO 对象等。
    (2)创建对象要访问外部信息或资源时，比如，读取数据库字段，获取访问授权token 信息，配置文件等。
    (3)创建需要统一管理生命周期的对象时，比如，会话信息、用户网页浏览轨迹对象等。
    (4)创建池化对象时，比如，连接池对象、线程池对象、日志对象等。这些对象的特性是：有限、可重用，使用工厂方法模式可以有效节约资源。
    (5)希望隐藏对象的真实类型时，比如，不希望使用者知道对象的真实构造函数参数等。

    4.3.抽象工厂模式介绍(使用相对少)

    4.3.1 抽象工厂模式介绍

    抽象工厂模式比工厂方法模式的抽象程度更高. 在工厂方法模式中每一个具
    体工厂只需要生产一种具体产品,但是在抽象工厂模式中一个具体工厂可以
    生产一组相关的具体产品,这样一组产品被称为产品族.产品族中的每一个产
    品都分属于某一个产品继承等级结构.

    1. 产品等级结构与产品族
      为了更好的理解抽象工厂, 我们这里先引入两个概念:
      在这里插入图片描述
      在上图中,每一个具体工厂可以生产属于一个产品族的所有产品,例如海尔工
      厂生产海尔电视机、海尔空调和海尔冰箱,所生产的产品又位于不同的产品
      等级结构中. 如果使用工厂方法模式,上图所示的结构需要提供9个具体工厂,
      而使用抽象工厂模式只需要提供3个具体工厂,极大减少了系统中类的个数.
      在这里插入图片描述
    4.3.2 抽象工厂模式原理

    在抽象工厂模式中,每一个具体工厂都提供了多个工厂方法,用于产生多种不同类型的产品.这些产品构成了一个产品族。
    在这里插入图片描述
    在这里插入图片描述

    4.3.3 抽象工厂模式实现

    抽象工厂

    /**
 * 抽象工厂: 在一个抽象工厂中可以声明多个工厂方法,用于创建不同类型的产品
 **/
public interface AppliancesFactory {

    AbstractTV createTV();

    AbstractFreezer createFreezer();

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    具体工厂: 每一个具体工厂方法,可以返回一个特定的产品对象,而同一个具体工厂所创建的产品对象构成了一个产品族.

    /**
 * 具体工厂
 **/
public class HairFactory implements AppliancesFactory {

    @Override
    public AbstractTV createTV() {
        return new HairTV();
    }

    @Override
    public AbstractFreezer createFreezer() {
        return new HairFreezer();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    public class HisenseFactory implements AppliancesFactory {

    @Override
    public AbstractTV createTV() {
        return new HisenseTV();
    }

    @Override
    public AbstractFreezer createFreezer() {
        return new HisenseFreezer();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    抽象产品

    public interface AbstractFreezer {}
public interface AbstractTV {}

    • 1
    • 2

    具体产品

    public class HairFreezer implements AbstractFreezer {}
public class HisenseFreezer implements AbstractFreezer {}
public class HairTV implements AbstractTV {}
public class HisenseTV implements AbstractTV {}

    • 1
    • 2
    • 3
    • 4
    
/**
 * 客户端
 **/
public class Client {

    private AbstractTV tv;

    private AbstractFreezer freezer;

    public Client(AppliancesFactory factory){

        //在客户端看来就是使用抽象工厂来生产家电
        this.tv = factory.createTV();
        this.freezer = factory.createFreezer();
    }

    public AbstractTV getTv() {
        return tv;
    }

    public void setTv(AbstractTV tv) {
        this.tv = tv;
    }

    public AbstractFreezer getFreezer() {
        return freezer;
    }

    public void setFreezer(AbstractFreezer freezer) {
        this.freezer = freezer;
    }

    public static void main(String[] args) {

        Client client = new Client(new HisenseFactory());
        AbstractTV tv = client.getTv();
        System.out.println(tv);

        AbstractFreezer freezer = client.getFreezer();
        System.out.println(freezer);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    4.3.4 抽象工厂模式总结

    在这里插入图片描述
    在这里插入图片描述

  • 相关阅读:
    websocket--技术文档--spring后台+vue基本使用
    Java版工程行业管理系统源码-专业的工程管理软件- 工程项目各模块及其功能点清单
    深入理解synchronized关键字
    热门开源项目OpenHarmony
    C/C++ 让黑框暂停的几种方法
    移动端手指事件和手机事件：
    微信小程序实战，基于vue2实现瀑布流
    Sony IMX118sensor驱动与视频数据处理
    Vue2常见的缺陷与Vue3带来的新特性
    安装Karmada
  • 原文地址：https://blog.csdn.net/weixin_39563769/article/details/133916355