2021-02-20实习日报

1. Builder建造者模式

项目中使用到了Builder建造者模式将复杂繁琐的的配置操作整合起来
建造者模式由产品，抽象建造者，具体建造者，指挥者等四个要素构成

1.1 模式的结构

建造者模式的主要角色如下

• 产品角色（product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个零部件。
• 抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法 getResult()。
• 具体建造者（Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。
• 指挥者：（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。

结构图

1.2 模式的实现

产品角色：包含多个组成部件的复杂对象

class Product{
	private String partA;
	private String partB;
	private String partC;
	
    public void setPartA(String partA) {
        this.partA = partA;
    }
    public void setPartB(String partB) {
        this.partB = partB;
    }
    public void setPartC(String partC) {
        this.partC = partC;
    }
    public void show() {
        //显示产品的特性
    }
}

抽象建造者：包含创建产平各个子部件的抽象方法

abstract class Builder {
    //创建产品对象
    protected Product product = new Product();
    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract void buildPartC();
    //返回产品对象
    public Product getResult() {
        return product;
    }
}

具体建造者：实现了抽象建造这接口

public class ConcreteBuilder extends Builder {
    public void buildPartA() {
        product.setPartA("建造 PartA");
    }
    public void buildPartB() {
        product.setPartB("建造 PartB");
    }
    public void buildPartC() {
        product.setPartC("建造 PartC");
    }
}

指挥者：调用建造者方法完成复杂对象的创建

class Director {
    private Builder builder;
    public Director(Builder builder) {
        this.builder = builder;
    }
    //产品构建与组装方法
    public Product construct() {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
        return builder.getResult();
    }
}

客户类

public class Client {
    public static void main(String[] args) {
        Builder builder = new ConcreteBuilder();
        Director director = new Director(builder);
        Product product = director.construct();
        product.show();
    }
}

2. @Qualifier注解

@Qualifier限定哪个bean应该被自动注入，当Spring无法判断出哪个bean应该被注入时，@Qualifier注解有助于消除歧义bean的自动注入
例子

public class Staff{    
    @Autowired    
    private user user;
}

我们有两个bean定义为Person类的实例

<beanid="staff"class="com.test.Staff"/>
 
<beanid="user1"class="com.test.User">
<property name="name"value="zhangsan"/></bean>
 
<beanid="user2"class="com.test.User">
<property name="name"value="lisi"/></bean>

Spring不知道该加载哪个Bean
运行会报错

Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException:    No unique bean of type [com.test.User] is defined:       expected single matching bean but found2: [user1, user2]

可以使用@Qualifier来解决

public class Staff
{
    @Autowired
    @Qualifier("user1")
    private User user;
}

3. @Transaction注解

两种情况

• 为了保证一个service层的方法中执行多个非查询语句操作都会采用
  项目中的例子

@Transactional(rollbackFor = {InvalidDataException.class, InternalServerException.class})
public class ModelManagerServiceImpl implements ModelManagerService {
    private final RedisTemplate<String, Object> jsonRedisTemplate;
    private final ModelMainMapper modelMainMapper;
    private final ModelExtraServiceImpl modelExtraService;

rollbackFor=InvalidDataException.class，保证凡是抛出InvalidDataException的异常，都会进行回滚

• 当某service层中有两个方法A() B() ，当方法A想要调用方法B时的标准事务一致性操作：
  例子

    @Transactional(rollbackFor = Throwable.class) //
    public void A() {
        // TODO  代码略...
        this.B();
    }
 
    private void B() {
    // TODO  代码略...
    }

当不同service层之间方法调用，则被调用的方法事务也还起作用，事务不太建议放到2个service中。同一工程内，controller中调用第一个service声明了Transactional，service中再调用其他service中非声明的事务，如果遇到RunTimeException则还是事务回滚的，但是尽量使用事务的方法，都加上Transactional声明

复习一下Spring事务的传播行为

• TransactionDefinition.PROPAGATION_REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。这是默认值。
• TransactionDefinition.PROPAGATION_REQUIRES_NEW：创建一个新的事务，如果当前存在事务，则把当前事务挂起。
• TransactionDefinition.PROPAGATION_SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
• TransactionDefinition.PROPAGATION_NOT_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。
• TransactionDefinition.PROPAGATION_NEVER：以非事务方式运行，如果当前存在事务，则抛出异常。
• TransactionDefinition.PROPAGATION_MANDATORY：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。
• TransactionDefinition.PROPAGATION_NESTED：如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION_REQUIRED。

4. Java的File.separator

File file = new File();//这句是新建一个文件
file.separator();//这个代表了系统目录中的间隔符，可以解决兼容问题

5. Mybatis Plus UpdateWrapper

再进行更新或者删除的时候，有时where条件复杂的话，可以使用UpdateWrapper来构造条件
实例
更新指定员工的邮箱和联系电话
sql实现

UPDATE t_employee SET email="123456@qq.com", phoneNumber="12345678" WHERE id=6

UpdateWrapper实现

@Test
public void updateByUpdateWrapper(){
  UpdateWrapper<Employee> updateWrapper=new UpdateWrapper<>();
  //UpdateWrapper<Employee> updateWrapper2 = Wrappers.<Employee>update();
  Employee employee=new Employee();
  employee.setEmail("1234@qq.com");
  employee.setPhoneNumber("1234567");
  updateWrapper.eq("id",6);
  int affectRows=employeeMapper.update(employee,updateWrapper);
  if(affectRows>0){
    System.out.println("更新成功");
  }else{
    System.out.println("更新失败");
  }
}

删除老员工

DELETE FROM t_employee WHERE DATE_FORMAT(birthday,'%Y-%m-%d')<="1990-01-01" AND departmentId=2

UpdateWrapper实现

@Test
public void deleteByUpdateWrapper2(){
  UpdateWrapper<Employee> updateWrapper=new UpdateWrapper<>();
  //UpdateWrapper<Employee> updateWrapper2 = Wrappers.<Employee>update();
  updateWrapper.apply("DATE_FORMAT(birthday,'%Y-%m-%d')<={0}","1990-01-01").eq("departmentId",2);
  int affectRows=employeeMapper.delete(updateWrapper);
  if(affectRows>0){
    System.out.println("删除成功");
  }else{
    System.out.println("删除失败");
  }
}

6. MyBatis Plus QueryWrapper

条件构造器关系示意图

实例
根据实体条件，删除记录，QueryWrapper实体对象封装操作类（可以为null）

    @Test
    public void delete() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper
                .isNull("name")
                .ge("age", 12)
                .isNotNull("email");
        int delete = mapper.delete(queryWrapper);
        System.out.println("delete return count = " + delete);
    }

项目中的使用

 //条件构造器，根据fid来进行操作
                QueryWrapper<ModelExtra> queryWrapper = new QueryWrapper<>();
                queryWrapper.eq("fid", fid);
                String finalOldHdfsPath = oldHdfsPath;
                String finalNewHdfsPath = newHdfsPath;
                List<ModelExtra> extras = modelExtraService.getBaseMapper().selectList(queryWrapper)
                        .stream()
                        .peek(modelExtra -> {
                            String hdfsPath = modelExtra.getHdfsPath();
                            modelExtra.setHdfsPath(hdfsPath.replace(finalOldHdfsPath, finalNewHdfsPath));
                        }).collect(Collectors.toList());

7. MyBatis Plus ServiceImpl

Mybatis Plus通用Service，mp框架同样提供了service层的封装支持，让我们能够简化service层的开发
具体使用
service接口继承IService，service实现类继承ServiceImpl
Iservice提供了所有通用常用的方法，包括批处理添加更新支持，以及lambda支持

8. Redis分布式锁的实现

8.1 redis命令介绍

• SETNX命令
  当且仅当key不存在，将key的值设为value，并返回1,若给定的key已经存在，则SETNX不做任何动作，返回0
• SETEX命令
  设置超时时间
• GET命令
  返回key所关联的字符串
• DEL命令
  删除key

8.2 实现思路

由于redis的setnx命令天生就适合用来实现锁的功能，这个命令只有在键不存在的情况下为键设置值。获取锁之后，其他程序再设置值就会失败，即获取不到锁。获取锁失败。只需不断的尝试获取锁，直到成功获取锁，或者到设置的超时时间为止。

另外为了防治死锁，即某个程序获取锁之后，程序出错，没有释放，其他程序无法获取锁，从而导致整个分布式系统无法获取锁而导致一系列问题，甚至导致系统无法正常运行。这时需要给锁设置一个超时时间，即setex命令，锁超时后，从而其它程序就可以获取锁了。

8.3 编码实现

Springboot结合redis实现

8.3.1 引入依赖

<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>

		<!-- 开启web-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		
		<!-- redis-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>

8.3.2 创建一个锁类

/**
 * 全局锁，包括锁的名称
 * Created by fangzhipeng on 2017/4/1.
 */
public class Lock {
    private String name;
    private String value;

    public Lock(String name, String value) {
        this.name = name;
        this.value = value;
    }

    public String getName() {
        return name;
    }

    public String getValue() {
        return value;
    }

}

8.3.3 创建分布式锁的具体方法

@Component
public class DistributedLockHandler {

    private static final Logger logger = LoggerFactory.getLogger(DistributedLockHandler.class);
    private final static long LOCK_EXPIRE = 30 * 1000L;//单个业务持有锁的时间30s，防止死锁
    private final static long LOCK_TRY_INTERVAL = 30L;//默认30ms尝试一次
    private final static long LOCK_TRY_TIMEOUT = 20 * 1000L;//默认尝试20s

    @Autowired
    private StringRedisTemplate template;

    /**
     * 尝试获取全局锁
     *
     * @param lock 锁的名称
     * @return true 获取成功，false获取失败
     */
    public boolean tryLock(Lock lock) {
        return getLock(lock, LOCK_TRY_TIMEOUT, LOCK_TRY_INTERVAL, LOCK_EXPIRE);
    }

    /**
     * 尝试获取全局锁
     *
     * @param lock    锁的名称
     * @param timeout 获取超时时间 单位ms
     * @return true 获取成功，false获取失败
     */
    public boolean tryLock(Lock lock, long timeout) {
        return getLock(lock, timeout, LOCK_TRY_INTERVAL, LOCK_EXPIRE);
    }

    /**
     * 尝试获取全局锁
     *
     * @param lock        锁的名称
     * @param timeout     获取锁的超时时间
     * @param tryInterval 多少毫秒尝试获取一次
     * @return true 获取成功，false获取失败
     */
    public boolean tryLock(Lock lock, long timeout, long tryInterval) {
        return getLock(lock, timeout, tryInterval, LOCK_EXPIRE);
    }

    /**
     * 尝试获取全局锁
     *
     * @param lock           锁的名称
     * @param timeout        获取锁的超时时间
     * @param tryInterval    多少毫秒尝试获取一次
     * @param lockExpireTime 锁的过期
     * @return true 获取成功，false获取失败
     */
    public boolean tryLock(Lock lock, long timeout, long tryInterval, long lockExpireTime) {
        return getLock(lock, timeout, tryInterval, lockExpireTime);
    }


    /**
     * 操作redis获取全局锁
     *
     * @param lock           锁的名称
     * @param timeout        获取的超时时间
     * @param tryInterval    多少ms尝试一次
     * @param lockExpireTime 获取成功后锁的过期时间
     * @return true 获取成功，false获取失败
     */
    public boolean getLock(Lock lock, long timeout, long tryInterval, long lockExpireTime) {
        try {
            if (StringUtils.isEmpty(lock.getName()) || StringUtils.isEmpty(lock.getValue())) {
                return false;
            }
            long startTime = System.currentTimeMillis();
            do{
                if (!template.hasKey(lock.getName())) {
                    ValueOperations<String, String> ops = template.opsForValue();
                    ops.set(lock.getName(), lock.getValue(), lockExpireTime, TimeUnit.MILLISECONDS);
                    return true;
                } else {//存在锁
                    logger.debug("lock is exist!！！");
                }
                if (System.currentTimeMillis() - startTime > timeout) {//尝试超过了设定值之后直接跳出循环
                    return false;
                }
                Thread.sleep(tryInterval);
            }
            while (template.hasKey(lock.getName())) ;
        } catch (InterruptedException e) {
            logger.error(e.getMessage());
            return false;
        }
        return false;
    }

    /**
     * 释放锁
     */
    public void releaseLock(Lock lock) {
        if (!StringUtils.isEmpty(lock.getName())) {
            template.delete(lock.getName());
        }
    }

}

8.3.4 用法

@Autowired
DistributedLockHandler distributedLockHandler;
Lock lock=new Lock("lockk","sssssssss);
if(distributedLockHandler.tryLock(lock){
	doSomething();
	distributedLockHandler.releaseLock();
}

8.4 注意点

在使用全局锁时为了防止死锁采用setex命令，这种命令需要根据具体的业务具体设置锁的超时时间，另外一个就是锁的粒度性

8.5 SETIFABSENT方法

SETIFABSENT是java中的方法
SETNX是redis中的方法
SETNX例子

SETNX mykey “Hello”
1
SETNX mykey “World”
0
GET mykey
“Hello”

SETIFABSENT方法

BoundValueOperations boundValueOperations = this.redisTemplate.boundValueOps(redisKey);
flag = boundValueOperations.setIfAbsent(value); // flag 表示的是否set
boundValueOperations.expire(seconds, TimeUnit.SECONDS);

if(!flag){ // 重复
    repeatSerial.add(serialNo);
    continue;
}else{// 没有重复
    norepeatSerial.add(serialNo);
}