在开发过程中，如果要测试某个service类的接口，按照以下流程操作：

引入依赖：

1
2
3
4
5

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

在单元测试类上添加@SpringTest 和 @RunWith(SpringRunner.class) 两个注解

方法上添加@Test注解，注意是org.junit.jupiter.api.Test

结构型—享元模式，提高对象的复用性质，避免创建过多的重复对象

实现方式

池化，将享元对象存放到一个集合中，与工厂方法配合获取/回收享元对象

经典案例：抢票案例、数据库连接池、String字面量管理优化、包装类Integer/Long中的享元模式

两种状态

Delegate Pattern 又叫委托模式，是一种面向对象的设计模式，允许对象组合实现与及城乡同的代码重用。它的基本作用就是负责任务的调用和分配，是一种特殊的静态代理，可以理解为全权代理。

代理模式注重过程，委派模式注重结果。委派模式属于行为模式，且不适于GOF23中设计模式之中。

委派模式有三个参与角色：

• 抽象任务角色

文章以jdk并发包中的一个策略模式实现作为开篇。

使用线程池处理并发任务时，当用户提交任务到线程池，线程池因为线程池已满或者线程池处于SHUTDOWN状态拒接任务的时候，会调用reject函数对任务进行后处理，代码如下：

1
2
3
4
5
6
7
8
9

代码摘自：java.util.concurrent.ThreadPoolExecutor

private volatile RejectedExecutionHandler handler;
private static final RejectedExecutionHandler defaultHandler =
        new AbortPolicy();
        
final void reject(Runnable command) {
    handler.rejectedExecution(command, this);
}

在线程池创建的时候，用户会初始化handler变量，或者使用默认的初始化defaultHandler，即AbortPolicy对象，AbortPolicy就是策略的一种实现，该策略丢弃被拒绝的任务，并抛出RejectedExecutionException异常。

1
2
3
4
5
6
7
8
9
10

代码摘自：java.util.concurrent.ThreadPoolExecutor

public static class AbortPolicy implements RejectedExecutionHandler {
    public AbortPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        throw new RejectedExecutionException("Task " + r.toString() +
                                             " rejected from " +
                                             e.toString());
    }
}

策略接口类：

1
2
3
4
5

代码摘自：java.util.concurrent.RejectedExecutionHandler

public interface RejectedExecutionHandler {
    void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}

@SpringBootApplication

我们经常直接将@SpringBootApplication打在了主类上，其实更加清晰的写法应该是将主类和SpringBoot配置类分开，如下所示：

1
2
3
4
5
6
7
8
9

@SpringBootApplication
public class SBConfiguration {
}

public class SBApplication {
	public static void main(String args[]) throws Exception{
		SpringApplication.run(SBConfiguration.class, args);
	}
}

如此一来，就能比较清晰的看出主类SBApplication只是程序的入口，没有什么特殊的。调用了SpringApplication的静态方法run，并使用SpringBoot主配置类SBConfigration.class作为参数。 主配置类就是打上@SpringBootApplication注释的类，首先看一下注释SpringBootApplication的代码：

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

@Target({ElementType.TYPE}) //表示该注解只能用于类型
@Retention(RetentionPolicy.RUNTIME)//表示该注解的生命周期可以维持到运行时
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
    ), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
    )})
public @interface SpringBootApplication {
}

这是一个复合注释，其中@SpringBootConfiguration代表了SpringBoot的配置类，除了测试时有些区别，大体上就是Spring标准@Configuration的替代品。

tail

显示文件的末尾部分，默认显示10行

• 举例：看日志文件时

  1	tail -fn 30 xxxx.log

nohup 是 no hang up 的缩写，就是不挂断的意思。

nohup命令：如果你正在运行一个进程，而且你觉得在退出帐户时该进程还不会结束，那么可以 使用nohup命令,该命令可以在你退出帐户/关闭终端之后继续运行相应的进程。

在缺省情况下该作业的所有输出都被重定向到一个名为nohup.out的文件中。nohup 命令运行由 Command参数和任何相关的Arg参数指定的命令，忽略所有挂断（SIGHUP）信号。在注销后使用 nohup 命令运行后台中的程序。要运行后台中的 nohup 命令，添加 & （表示“and”的符号）到命令的尾部。

案例

1. nohup command > myout.file 2>&1 &

在上面的例子中，0 – stdin (standard input)，1 – stdout (standard output)，2 – stderr (standard error) ；
2>&1是将标准错误（2）重定向到标准输出（&1），标准输出（&1）再被重定向输入到myout.file文件中。

2. 0 22 * /usr/bin/python /home/pu/download_pdf/download_dfcf_pdf_to_oss.py > /home/pu/download_pdf/download_dfcf_pdf_to_oss.log 2>&1

这是放在crontab中的定时任务，晚上22点时候怕这个任务，启动这个python的脚本，并把日志写在download_dfcf_pdf_to_oss.log文件中

1.建表时创建

1
2
3
4
5
6
7
8

CREATE TABLE test
(  
  test_id SERIAL primary key ,  
  test_name character varying,  
  contactname character varying,  
  phone character varying,  
  country character varying  
)

2.在已建表的情况下创建

1
2
3
4
5
6
7
8

CREATE SEQUENCE test_id_seq  
START WITH 1  
INCREMENT BY 1  
NO MINVALUE  
NO MAXVALUE  
CACHE 1;  
  
alter table test alter column id set default nextval('test_id_seq');

1、合成复用原则

合成复用原则（Composite/Aggregate Reuse Principle，CARP）

是指尽量使用对象组合（has-a）/ 聚合（contanis-a），而不是继承关系（is-a）达到软件复用的目的。

可以使系统更加灵活，降低类与类之间的耦合度，一个类的变化对其他类造成的影响相对较少。

继承我们叫做白箱复用，相当于把所有的实现细节暴露给子类。组合/聚合也称之为黑箱复用，对类 以外的对象是无法获取到实现细节的。要根据具体的业务场景来做代码设计，其实也都需要遵循 OOP 模型。

2、里式替换原则

里氏替换原则（Liskov Substitution Principle，LSP）

在java代码优化时一般会遵循一个原则， 尽量使用移位来代替’a/b’和’a*b’的操作，这两个操作代价很高，使用移位操作将会更快更有效。

1、三种移位操作

• “<<” 不带符号左移，符号位不动，低位补0，高位丢失
• “>>” 不带符号右移，符号位不动，正数高位补0，负数高位补1(机器数为补码)，低位丢失
• “>>>” 带符号右移，高位补0，低位丢失