@Override
@Transactional // 保证事件和用户注册的一致性
public Long register(User insert) {
    boolean save = userDao.save(insert);
    // 用户注册的事件  -> 谁订阅就给谁发送通知 （1.Mq  2.ApplicationEventPublisher）
    applicationEventPublisher.publishEvent(new UserRegisterEvent(this, insert)); // this事件订阅者，发送端
    return insert.getId();
}

/**
 * @className: UserRegisterEvent
 * @author: Calyee
 * @description: 用户注册事件
 * @version: 1.0
 */
@Getter
public class UserRegisterEvent extends ApplicationEvent {
    private User user;

    public UserRegisterEvent(Object source, User user) {
        super(source);
        this.user = user;
    }
}

/**
 * @className: UserRegisterListener
 * @author: Calyee
 * @description: 用户注册监听
 * @version: 1.0
 */
@Component
public class UserRegisterListener {
    @Autowired
    private IUserBackpackService userBackpackService;
    @Autowired
    private UserDao userDao;
    /**
     * 发送改名卡
     *
     * @param userRegisterEvent 注册事件
     */
    @Async
    @TransactionalEventListener(classes = UserRegisterEvent.class, phase = TransactionPhase.AFTER_COMMIT) // 事务提交后
    public void sendCard(UserRegisterEvent userRegisterEvent) {
        User user = userRegisterEvent.getUser();
        userBackpackService.acquireItem(user.getId(), ItemEnum.MODIFY_NAME_CARD.getId(), IdempotentEnum.UID, user.getId().toString());
    }
    /**
     * 发送 前10名/100名 注册的徽章
     */
    @Async
    @TransactionalEventListener(classes = UserRegisterEvent.class, phase = TransactionPhase.AFTER_COMMIT)
    public void sendBadge(UserRegisterEvent userRegisterEvent) {
        User user = userRegisterEvent.getUser();
        int registeredUserCount = userDao.count();
        if(registeredUserCount < 10){
            userBackpackService.acquireItem(user.getId(), ItemEnum.REG_TOP10_BADGE.getId(), IdempotentEnum.UID, user.getId().toString());
        }else if(registeredUserCount <100){
            userBackpackService.acquireItem(user.getId(), ItemEnum.REG_TOP100_BADGE.getId(), IdempotentEnum.UID, user.getId().toString());
        }
    }
}

@Data     // Get Set
// 当processor读取到application.yml配置文件以product,存储到当前对象中
@ConfigurationProperties(prefix = "product")
@Component // IOC
public class Product implements Serializable {

    private String pname;
    private Double price;
    private Boolean isUsed; // is-used
    private Date manDate;   // man-date
    private Map<String, Object> attributes;
    private Address address;
    private List<String> types;
}

@Data
public class Address implements Serializable {
    private String province;
    private String city;
}

@RunWith(SpringRunner.class)
@SpringBootTest()
public class ProductTest {
    @Autowired
    private Product product;
    @Test
    public void testProduct() {
        Assert.assertNotNull(product);
        Assert.assertEquals("apple", product.getPname());
    }
}

// 1.读取例如properties配置  并以key value存储
@PropertySource(value = {"classpath:db.properties"})// value可以加多个

@Value(${username})
private String username;  // root

// 2.读取spring.xml配置文件
@ImportResource(locations = {"classpath:spring.xml"})

@Autowired
@Qualifier(value = "us") // 根据bean的唯一id获取,因为在User类里面加了@Component注解,已经注入过了(id=user)
private User user;

java -Dserver.port=9090 -jar xxx.jar

// 读取环境变量信息,spring启动时,自动加载
@Autowired
private Environment environment;

@Resource
private ConfigurableEnvironment configurableEnvironment;

@Value("${driverClassName}")
private String driverName;
@Value("${username}")
private String username;
@Value("${password}")
private String password;
@Value("${url}")
private String url;

@Bean
// 表示指定了 spring.profiles.active: test的时候用这个数据源
@Profile("test") // 测试数据源
public DataSource localDataSource(){
    DriverManagerDataSource source = 
        new DriverManagerDataSource();
    source.setDriverClassName(driverName);
    source.setUsername(username);
    source.setPassword(password);
    source.setUrl(url);
    return source;
}
@Bean
// 表示指定了 spring.profiles.active: prod的时候用这个数据源
@Profile("prod") 
public DataSource localDataSource(){
    DruidDataSource source = 
        new DruidDataSource();
    source.setDriverClassName(driverName);
    source.setUsername(username);
    source.setPassword(password);
    source.setUrl(url);
    return source;
}

@Component
public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

// 获取springboot的启动类
@SpringBootTest(classes = SpringBootApplication.class) 
@RunWith(SpringRunner.class)

@SpringBootTest() // 获取springboot的启动类
@RunWith(SpringRunner.class)
public class CalculatorTest {

    // spring支持IOC: 控制反转  再进行DI注入
    @Autowired
    private Calculator calculator;

    @Test
    void add() {
        int add = calculator.add(1, 2);
        // 传统sout输出   不推荐
        // 推荐  断言
        // 优点: 与预期结果一致,绿   不一致:红   便于捕捉没通过预期的方法
//        System.out.println("add = " + add);
        Assert.assertEquals(3, add); // 绿
    }
}

/**
 * 当前方法是测试套件
 * 就是把CalculatorTest 和 OtherTest 
 * 两个类里面的方法 全部一起测试,假如用了断言 测试完成后
 * 通过与未通过一目了然
 */
@RunWith(Suite.class)
@Suite.SuiteClasses({CalculatorTest.class,OtherTest.class}) // 测试指定类
public class SuiteTest {
}

@Test
@Disabled("This test is not ready yet.")
public void disabledTest() {
    // 没有写完的逻辑 或是 已经不需要测试的逻辑
}

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class OrderTest {

    @Order(1)
    @Test
    public void testMethod1() {
        // 在这里写测试逻辑
    }
    
    @Order(2)
    @Test
    public void testMethod2() {
        // 在这里写测试逻辑
    }
}

@BeforeAll
public static void initOperate() {
    // 初始化操作
}

@AfterAll
public static void destoryOperate() {
    // 资源销毁操作
}

@BeforeEach
public void beforeEachTest() {
    // 执行前的准备工作
}

@AfterEach
public void afterEachTest() {
    // 执行后的清理工作
}

@RepeatedTest(6)
public void repeatedTest() {
    // 该测试方法会重复执行6次
}

@ParameterizedTest
@ValueSource(strings = { "name1", "name2", "name3" })
public void testParameter(String name) {
    // 使用参数化的名称进行测试
}

@SpringBootTest
@AutoConfigureMockMvc
public class MyControllerIntegrationTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testController() throws Exception {
        mockMvc.perform(get("/api/someendpoint"))
                .andExpect(status().isOk())
                .andExpect(content().contentType(MediaType.APPLICATION_JSON));
    }
}

@Component
public class UpdateViewCountJob {
    @Autowired
    private RedisCache redisCache;
    @Autowired
    private ArticleService articleService;
    @Scheduled(cron = "0 */10 * * * ?") // 开启定时任务
    public void updateViewCountJob(){
        // 获取redis中存取的浏览量
        Map<String, Integer> viewCountMap = redisCache.getCacheMap(SystemConstants.ARTICLE_VIEW_COUNT);
        // 双列集合不能用流,可以先转entrySet(键值对)或者keySet
        List<Article> articleList = viewCountMap.entrySet()
                .stream()                            //  key(long)  value(long)
                .map(entry -> new Article(Long.valueOf(entry.getKey()), entry.getValue().longValue()))
                .collect(Collectors.toList());
        // 更新到数据库
        articleService.updateBatchById(articleList);
    }
}

/**
 * @ClassName ViewCountRunner
 * @Description 在启动之前对浏览量进行查询 然后缓存到redis里面
 */
@Component
public class ViewCountRunner implements CommandLineRunner {
    @Autowired
    private ArticleMapper articleMapper;
    @Autowired
    private RedisCache redisCache;
    @Override
    public void run(String... args) throws Exception {
        // 查询博客信息 id + viewCount           key value
        List<Article> articleList = articleMapper.selectList(null);
        Map<String, Integer> map = new HashMap<>();
//        articleList.forEach(item->{
//            map.put(String.valueOf(item.getId()),item.getViewCount());
//        });
        map = articleList.stream()
                .collect(Collectors.toMap(article -> article.getId().toString(), // key
                        article -> {                                  // value
                            return article.getViewCount().intValue();   // 1L 在redis中要用Integer
                        }));
        // 存储到redis
        redisCache.setCacheMap(SystemConstants.ARTICLE_VIEW_COUNT,map);
    }
}

public class ImportList implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        String url = "META-INF/"
        // TODO: File file = new File(url); // 将所有需要的全类名 封装到一个固定的文件内 在依次读取
        // file.listFile();
        return new String[]{
            // 把扫描到的文件名添加到此处
        };
    }
}

@RestController
public class SpringBeansGetInfoClass implements ApplicationContextAware {
    private ApplicationContext context;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.context = applicationContext;
    }
    // 读取beanName
    @GetMapping("/getSpringBeanInfo")
    public void getBeanNameInfo(){
        for (String name : this.context.getBeanDefinitionNames()) {
            System.out.println(name);
        }
    }
}

/**
 *  这个是一个WebServer自动配置类
 *  该案例为动态切换Tomcat和Jetty服务器的实例配置类
 */
@Configuration // 交给Spring管理
public class WebServerAutoConfiguration {
    // Spring配置文件
    // WebServer自动配置类
    @Bean
    // 条件加载,根据TomcatCondition中约束的条件,动态注入Bean
    @Conditional(TomcatCondition.class) 
    public TomcatWebServer tomcatWebServer() {
        return new TomcatWebServer();
    }
    @Bean
    @Conditional(JettyCondition.class) // Jetty服务器条件加载判断
    public JettyWebServer jettyWebServer() {
        return new JettyWebServer();
    }
}

public class TomcatCondition implements Condition {
    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        // 判断项目中是否有符合条件的依赖
        try {
            // 利用类加载器,加载需要判断的类
  conditionContext.getClassLoader().loadClass("org.apache.catalina.startup.Tomcat");
            return true;// 能走到这个地方 证明有
        } catch (ClassNotFoundException e) {
            return false; // 没有该类
        }
//        // 如果返回true,则符合条件
//        return false;
    }
}

@ConfigurationProperties(
    prefix = "server", // 读取配置文件属性
    ignoreUnknownFields = true
)
public class ServerProperties {
    private Integer port;
    private InetAddress address;
    @NestedConfigurationProperty
    private final ErrorProperties error = new ErrorProperties();
    private ForwardHeadersStrategy forwardHeadersStrategy;
    private String serverHeader;
    private DataSize maxHttpHeaderSize = DataSize.ofKilobytes(8L);
    private Shutdown shutdown;
    @NestedConfigurationProperty
    private Ssl ssl;
    @NestedConfigurationProperty
    private final Compression compression;
    @NestedConfigurationProperty
    private final Http2 http2;
    private final Servlet servlet;
    private final Reactive reactive;
    private final Tomcat tomcat;
    private final Jetty jetty;
    private final Netty netty;
    private final Undertow undertow;
	// 方法省略
}

@AutoConfiguration
@ConditionalOnWebApplication  // 注册ServerProperties配置类
@EnableConfigurationProperties({ServerProperties.class}) // 主要注解
public class EmbeddedWebServerFactoryCustomizerAutoConfiguration {
    public EmbeddedWebServerFactoryCustomizerAutoConfiguration() {
    }

    @Configuration(
        proxyBeanMethods = false
    )
    @ConditionalOnClass({HttpServer.class})
    public static class NettyWebServerFactoryCustomizerConfiguration {
        public NettyWebServerFactoryCustomizerConfiguration() {
        }

        @Bean
        public NettyWebServerFactoryCustomizer nettyWebServerFactoryCustomizer(Environment environment, ServerProperties serverProperties) {
            return new NettyWebServerFactoryCustomizer(environment, serverProperties);
        }
    }
    // 以下的省略   
}

@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 {
    @AliasFor(
        annotation = EnableAutoConfiguration.class
    )
    Class<?>[] exclude() default {};
// 略
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
    Class<?>[] exclude() default {};
    String[] excludeName() default {};
}

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
    private static final AutoConfigurationEntry EMPTY_ENTRY = new AutoConfigurationEntry();
    private static final String[] NO_IMPORTS = new String[0];
    private static final Log logger = LogFactory.getLog(AutoConfigurationImportSelector.class);
    private static final String PROPERTY_NAME_AUTOCONFIGURE_EXCLUDE = "spring.autoconfigure.exclude";
    private ConfigurableListableBeanFactory beanFactory;
    private Environment environment;
    private ClassLoader beanClassLoader;
    private ResourceLoader resourceLoader;
    private ConfigurationClassFilter configurationClassFilter;
	// 此处方法构造器省略
}

public interface ImportSelector {
    // 重写该方法
    String[] selectImports(AnnotationMetadata importingClassMetadata);
    @Nullable
    default Predicate<String> getExclusionFilter() {
        return null;
    }
}

// 返回一个字符串数组,保存扫描类的路径
public String[] selectImports(AnnotationMetadata annotationMetadata) {
    if (!this.isEnabled(annotationMetadata)) {
        return NO_IMPORTS;
    } else {
        AutoConfigurationEntry autoConfigurationEntry = 
            // 通过该方法(getAutoConfigurationEntry)获取自动配置的项
            this.getAutoConfigurationEntry(annotationMetadata);
        return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
    }
}

protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
    if (!this.isEnabled(annotationMetadata)) {
        return EMPTY_ENTRY;
    } else {
        AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
        List<String> configurations = 
            // 获取候选的配置属性  (点进方法)
            this.getCandidateConfigurations(annotationMetadata, attributes);
        configurations = this.removeDuplicates(configurations);
        Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
        this.checkExcludedClasses(configurations, exclusions);
        configurations.removeAll(exclusions);
        configurations = this.getConfigurationClassFilter().filter(configurations);
        this.fireAutoConfigurationImportEvents(configurations, exclusions);
        return new AutoConfigurationEntry(configurations, exclusions);
    }
}

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    List<String> configurations = new 
        // 加载工厂 bean  ->  loadFactoryNames()
        ArrayList(SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader()));
     // 读取第二个配置文件 ->  load()
    ImportCandidates.load(AutoConfiguration.class, this.getBeanClassLoader()).forEach(configurations::add);
    Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories nor in META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports. If you are using a custom packaging, make sure that file is correct.");
    return configurations;
}

@Configuration
@ConditionalOnClass({TimeFunction.class}) // 如果有这个类字节码才加载
@EnableConfigurationProperties({TimeProperties.class}) // IOC 属性类
public class DateFormatAutoConfiguration {
    @Bean
    public TimeFunction timeFunction(){
        return new TimeFunction();
    }
}

@ConfigurationProperties(prefix = "hang.time")
public class TimeProperties {

    private String format = "yyyy-MM-dd HH:mm:ss";
    
    public String getFormat() {
        return format;
    }
    public void setFormat(String format) {
        this.format = format;
    }
}

// 要托管这个类 -> @Bean注解将这个类在@Component
public class TimeFunction { 
    @Autowired
    private TimeProperties timeProperties;
    public String showTime(String name){
        Date date = new Date();
        DateFormat df = new SimpleDateFormat(timeProperties.getFormat());
        String format = df.format(date);
        return "欢迎您:" + name + "现在是:" + format;
    }
}

@ComponentScan(excludeFilters = {
        @ComponentScan.Filter(
                type = FilterType.CUSTOM,
                classes = {TypeExcludeFilter.class}
        ),@ComponentScan.Filter(
                type = FilterType.CUSTOM,
        classes = {AutoConfigurationExcludeFilter.class}
        )
})

@Configuration
public class AppConfig(){
    @Bean
    public OrderService orderService(){
        return new OrderService();
    }
}

public class HangTypeExcludeFilter extends TypeExcludeFilter{
    @Override
    public boolean match(MetadataReader metadataReader,  MetadataReaderFactory metadataReaderFactory){
        return metadataReader.getClassMetadata().getClassName()
            .equals(UserService.class.getName());
    }
}

public class HangApplicationContextInitializer implements ApplicationContextInitializer{
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext){
        // 添加一个单例bean(排除过滤器)
        applicationContext.getBeanFactory()
            .regiseterSingleton("HangTypeExcludeFilter",new HangTypeExcludeFilter());
    }
}

@RestController
@RequestMapping("/user")
public class UserController{
    @Autowired
    private UserService userService;

    @GetMapping("/getById")
    public User getById(@RequestParam("id") Integer id){
        return userService.getUserInfoById(id);
    }
    @PostMapping("/save")
    public String save(@RequestBody User user){
        return userService.saveUserInfo(user)
                ? "保存成功" : "保存失败";
    }
}

@Slf4j
@RunWith(SpringRunner.class) // Junit4
@SpringBootTest(classes = {MockApplication.class},
// 在每一次进行mock测试时 启用随机端口启动 为例避免多个测试用例同时启动时不会产生端口占用问题
        webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
// 自动配置和启用MockMvc配置  如果不加这个注解 下面是不能注入的
@AutoConfigureMockMvc(addFilters = false)
public class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void getById() {
        // 预期对象
        User user = new User(1, "w", "a", "悟空",
                "song@foxmail.com", "13283718600", "男",
                1, null, "天子脚下");
        // 使用注入的mockMvc模拟发送请求
        // MockMvcRequestBuilders: 请求构建器
        try {
            Integer id = 1;
            // 在请求后面还可以指定请求类型 例如APPLICATION_JSON_VALUE
            mockMvc.perform(MockMvcRequestBuilders.get("/user/getById")
                            .contentType(MediaType.APPLICATION_JSON_VALUE)
                            // 这里还能设置header
                            .param("id","1")
                    )
                    // MockMvcResultMatchers: mockMvc结果匹配器
                    .andExpect(MockMvcResultMatchers.status().isOk()) // 例如当前为 匹配状态码为200或者其他可以表示成功的
                    // 这个是用于取返回body的  $.name代表取body里面的name字段 假如还有
                    .andExpect(MockMvcResultMatchers.jsonPath("$.name", Matchers.equalToIgnoringCase(user.getName())))
                    // 如果状态码符合预期 则进行print输出响应信息
                    .andDo(MockMvcResultHandlers.print())
                    // 真正请求得到响应的内容,真正执行的返回值
                    .andReturn();
        } catch (Exception e) {
            log.error("当前方法为:{},发生了异常", "getById");
            throw new RuntimeException(e);
        }
    }

    @Test
    public void save() {
    }
}

@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest(classes = {MockApplication.class},
// 在每一次进行mock测试时 启用随机端口启动 为例避免多个测试用例同时启动时不会产生端口占用问题
        webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
// 自动配置和启用MockMvc配置  如果不加这个注解 下面是不能注入的
//@AutoConfigureMockMvc(addFilters = false)
public class UserControllerTest {
    @Autowired
    private WebApplicationContext webApplicationContext;
    private MockMvc mockMvc;
    @Before
    public void setUp() {
        mockMvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();
    }
    @Test
    @DisplayName("文本响应测试用例")
    public void getById() {
        // 测试代码
    }
    @Test
    public void save() {
    }
}

// 在请求后面还可以指定请求类型 例如APPLICATION_JSON_VALUE
mockMvc.perform(MockMvcRequestBuilders.get("/user/getById")
                .contentType(MediaType.APPLICATION_JSON_VALUE)
                .param("id", "1")
               )
    // MockMvcResultMatchers: mockMvc结果匹配器
    .andExpect(MockMvcResultMatchers.status().isOk()) // 例如当前为 匹配状态码为200或者其他可以表示成功的
    // 这个是用于取返回body的
    .andExpect(MockMvcResultMatchers.jsonPath("$.name", Matchers.equalToIgnoringCase(user.getName())))
    // 如果状态码符合预期 则进行print输出响应信息
    .andDo(print())
    // 真正请求得到响应的内容,真正执行的返回值
    .andReturn();

// JSON 格式 -> content
mockMvc.perform(MockMvcRequestBuilders.post("/user/save")
                .contentType(MediaType.APPLICATION_JSON)
                .content("{\n" +
                         "  \"uid\": \"1\",\n" +
                         "  \"username\": \"w\"" +
                         "}")
                // MockMvcResultMatchers: mockMvc结果匹配器
                .accept(MediaType.APPLICATION_JSON))
    .andDo(print());
// From 格式 -> param
mockMvc.perform(MockMvcRequestBuilders.post("/user/save")
                .contentType(MediaType.APPLICATION_FORM_URLENCODED)
                .param("uid", "1")
                .param("username", "w")
                .accept(MediaType.APPLICATION_JSON))
    .andDo(print());

@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest(classes = {MockApplication.class},
// 在每一次进行mock测试时 启用随机端口启动 为例避免多个测试用例同时启动时不会产生端口占用问题
        webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class UserServiceTest {

    @MockBean // 模拟Bean:Mockito 会帮我们创建一个假的 Mock 对象，替换掉 Spring 中已存在的那个真实的 userDao Bean
    private UserMapper userMapper;

    @Autowired
    private UserService userService;

    @Test
    @DisplayName("测试没有dao数据访问层")
    public void testEmptyMapper() {
        User expectUser = new User(1, "测试没有dao数据访问层", "11", "测试没有dao数据访问层","song@foxmail.com", "13283718600", "男", 1, null, "天子脚下");
        // Mockito.when( 对象.方法名() ).thenReturn( 自定义结果 )
        Mockito.when(userMapper.selectById(1))
                .thenReturn(new User(1, "测试没有dao数据访问层", "11", "测试没有dao数据访问层","song@foxmail.com", "13283718600", "男", 1, null, "天子脚下"));
        
        User user = userService.getUserInfoById(1); // 访问模拟的Dao
        Assert.assertEquals(expectUser,user);       // 断言正确
    }
    
    @Test
    @DisplayName("测试Service")
    public void testService() {
        // Mockito.when( 对象.方法名() ).thenReturn( 自定义结果 )
        Mockito.when(userService.getUserInfoById(1))
                .thenReturn(new User(1, "测试Service", "11", "测试没有dao数据访问层","song@foxmail.com", "13283718600", "男", 1, null, "天子脚下"));
        User user = userService.getUserInfoById(1);
        log.info(user.toString());
    }
}

Mockito.when(userService.getUserById(Mockito.anyInt()))
       .thenReturn(new User(3, "Calyee"));
User user1 = userService.getUserById(3); // 回传的user的名字为Calyee
User user2 = userService.getUserById(200); // 回传的user的名字也为Calyee

Mockito.when(userService.getUserById(3)).thenReturn(new User(3, "Calyee"));
User user1 = userService.getUserById(3); // 回传的user的名字为Calyee -> 为预设期盼
User user2 = userService.getUserById(200); // 回传的user为null

Mockito.when(userService.insertUser(Mockito.any(User.class))).thenReturn(100);
Integer i = userService.insertUser(new User()); //会返回100

Mockito.when(userService.getUserById(1))
       .thenThrow(new RuntimeException("mock throw exception"));
User user = userService.getUserById(1); //会抛出一个RuntimeException

Mockito.doThrow(new RuntimeException("mock throw exception"))
       .when(userService).print();
userService.print(); //会抛出一个RuntimeException

@RestController
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/test")
    public String test(){
        return userService.test();
    }
}

@Service
public class UserService {
    public String test(){
        return "Hello My SpringBoot!";
    }
}

/**
 * @ClassName MyApplication
 * @Description 自定义SpringBoot
 * @Author QiuLiHang
 * @Version 1.0
 */
@HangSpringBootApplication // 该注解里面包含了ComponentScan注解
public class MyApplication {
    public static void main(String[] args) {
        HangSpringApplication.run(MyApplication.class);
    }
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Configuration
@ComponentScan  // 默认扫描当前解析类的包路径,传给run方法的类
public @interface HangSpringBootApplication {
}

public class HangSpringApplication {
    public static void run(Class clazz){
    }
}

public class HangSpringApplication {
    public static void run(Class clazz){
         // 创建Spring容器
        AnnotationConfigWebApplicationContext applicationContext =
                new AnnotationConfigWebApplicationContext();
        // 注册: clazz -> Spring容器的配置类
        applicationContext.register(clazz);
        // 刷新容器,加载被扫描的bean
        applicationContext.refresh();
        // 启动Tomcat (此处未实现启动其他服务器)
        startTomcat(applicationContext);
    }
}

public static void startTomcat(WebApplicationContext applicationContext){
		// 启动 Tomcat
        Tomcat tomcat = new Tomcat();

        Server server = tomcat.getServer();
        Service service = server.findService("Tomcat");

        Connector connector = new Connector();
        connector.setPort(8081); // 连接端口

        Engine engine = new StandardEngine();
        engine.setDefaultHost("localhost");// 本地测试

        Host host = new StandardHost();
        host.setName("localhost");

        String contextPath = "";
        Context context = new StandardContext();
        context.setPath(contextPath);
        context.addLifecycleListener(new Tomcat.FixContextListener());

        host.addChild(context);
        engine.addChild(host);

        service.setContainer(engine);
        service.addConnector(connector);

        // SpringMVC 处理请求  注册DispatcherServlet
        tomcat.addServlet(contextPath, "dispatcher",
                new DispatcherServlet(applicationContext));// 传入Spring容器
        context.addServletMappingDecoded("/*", "dispatcher");

        try {
            tomcat.start();
        } catch (LifecycleException e) {
            e.printStackTrace();
        }

    }

/**
 * 对自定义服务器调用 实现抽象化
 */
public interface WebServer {
    /**
     * 服务启动抽象接口
     */
    public void start(WebApplicationContext applicationContext);
}

/**
 * @ClassName TomcatWebServer
 * @Description Tomcat服务
 * @Author QiuLiHang
 * @Version 1.0
 */
public class TomcatWebServer implements WebServer{
    /**
     *	Tomcat服务启动类
     */

    @Override
    public void start(WebApplicationContext applicationContext) {
        Tomcat tomcat = new Tomcat();

        Server server = tomcat.getServer();
        Service service = server.findService("Tomcat");

        Connector connector = new Connector();
        connector.setPort(8081);

        Engine engine = new StandardEngine();
        engine.setDefaultHost("localhost");

        Host host = new StandardHost();
        host.setName("localhost");

        String contextPath = "";
        Context context = new StandardContext();
        context.setPath(contextPath);
        context.addLifecycleListener(new Tomcat.FixContextListener());

        host.addChild(context);
        engine.addChild(host);

        service.setContainer(engine);
        service.addConnector(connector);

        // SpringMVC 处理请求
        tomcat.addServlet(contextPath, "dispatcher",
                new DispatcherServlet(applicationContext));// 传入Spring容器
        context.addServletMappingDecoded("/*", "dispatcher");

        try {
            tomcat.start();
        } catch (LifecycleException e) {
            e.printStackTrace();
        }
    }
}

/**
 * @ClassName JettyWebServer
 * @Description Jetty服务启动类
 * @Author QiuLiHang
 * @Version 1.0
 */

public class JettyWebServer implements WebServer{
    @Override
    public void start(WebApplicationContext applicationContext) {
        System.out.println("启动jetty");
    }
}