[01:52:31] fdasfsdafasdfasf
[02:42:32] fdasfdsafdsa
[03:32:53] gfdgfdgfd
[04:22:43] rewrewrw
[05:12:23] tfhfghfg
[06:02:29] daadfdcvcv
[07:12:56] 322143543
[08:22:11] hgjhjhhj

# 这样就能匹配
\[\d\d:\d\d:\d\d\]

# 上面写的有点傻
\[\d{2}:\d{2}:\d{2}\]

# 再次简化
\[[\d:]+\]

String a = "abcdef\"\'\n";
// 双引号 单引号 换行
System.out.println(a);
// 两个斜杠
System.out.println("\\\\");

{n} 正好出现n次
{n,m}  最少n次，最多m次
{n,}  最少n次，最多不限

+  <===> {1,}
?  <===> {0,1}

*  <===> {0,} 可以可无  不推荐使用容易误导

Pattern p = Pattern.compile("[aeiou\\]]]"); // 匹配 a/e/i/o/u/] 由于在 java世界里 所以 ']'要添加转义 '\]'才可以

String a2 = "1.2.3";
System.out.println(Arrays.toString(a2.split(".")));
// System.out.println(a2.split("\.")); 转义 \ 需要在此转义
System.out.println(Arrays.toString(a2.split("\\.")));

public class Demo1 {
    // 这样就不会每次都编译
    public static final Pattern p = Pattern.compile("你要匹配的正则表达式");
}

"你的字符串".replaceAll("\\s","")

String s1 = "\\";
System.out.println(s1.matches("\\\\")); // 匹配 \

String s = "\\\\N";
System.out.println(s.matches("\\\\\\\\N")); // 匹配 \\N

Pattern telPattern = Pattern.compile("\\d{3}-\\d{8}|\\d{4}-\\d{7}");
System.out.println(telPattern.matcher("010-12345678").find()); // true
System.out.println(telPattern.matcher("010-1234567").find()); // false

Pattern telPattern2 = Pattern.compile("(\\d{3})-\\d{8}|\\d{4}-\\d{7}");
Matcher matcher = telPattern2.matcher("010-12345678");

while(matcher.find()){
    System.out.println(matcher.group(0)); // 0 代表整个被匹配的文本 结果是 010-12345678
    System.out.println(matcher.group(1)); // 1 代表整个被匹配的文本中第一组我们感兴趣的信息  结果是 010
}

Pattern telPattern3 = Pattern.compile("(\\d{3})-(\\d{8})|(\\d{4})-(\\d{7})");
Matcher matcher = telPattern3.matcher("010-12345678\n5730-1234567\nfff-dfadsfds");

while(matcher.find()){
    System.out.println(matcher.group(0));
    System.out.println(matcher.group(1));
    System.out.println(matcher.group(2));
    System.out.println(matcher.group(3));
    System.out.println(matcher.group(4));
}

运行结果：
010-12345678
010
12345678
null
null
5730-1234567
null
null
5730
1234567

// Pattern telPattern3 = Pattern.compile("(\\d{3})-(\\d{8})|(\\d{4})-(\\d{7})"); 
   Pattern telPattern3 = Pattern.compile("(\\d{3})-(\\d{8})|(\\d{4}-(\\d{7}))");
Matcher matcher = telPattern3.matcher("010-12345678\n5730-1234567\nfff-dfadsfds");

while(matcher.find()){
    System.out.println(matcher.group(0));
    System.out.println(matcher.group(1));
    System.out.println(matcher.group(2));
    System.out.println(matcher.group(3));
    System.out.println(matcher.group(4));
}

运行结果：
010-12345678
010
12345678
null
null
5730-1234567
null
null
5730-1234567
1234567

Pattern telPattern3 = Pattern.compile("(\\d{3})-(\\d{8})|(?:\\d{4})-(\\d{7})");
Matcher matcher = telPattern3.matcher("010-12345678\n5730-1234567\nfff-dfadsfds");
while(matcher.find()){
    System.out.println(matcher.group(0));
    System.out.println(matcher.group(1));
    System.out.println(matcher.group(2));
    System.out.println(matcher.group(3));
    // System.out.println(matcher.group(4)); 限制忽略了一个分组 所以它没有第四个分组
}

运行结果:
010-12345678
010
12345678
null
5730-1234567
null
null
1234567

@Service
public class RankService {
    @Autowired
    private UserMapper userMapper;

    @Autowired
    RankDao rankDao;

    public List<RankItem> doService(){
        return rankDao.getRank();
    }
}

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
public @interface Cache {

}

@Service
public class RankService {
    @Autowired
    private UserMapper userMapper;

    @Autowired
    RankDao rankDao;

    @Cache
    public List<RankItem> doService(){
        return rankDao.getRank();
    }
}

// @Aspect 声明它是一个切面
// @Configuration 是跟 spring有关的配置 运行的时候把它拷贝进来
@Aspect
@Configuration
public class CacheAspect {
    @Around("@annotation(hello.anno.Cache)")
    public Object cache(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("method is called");
        return joinPoint.proceed();
    }
}

// @Aspect 声明它是一个切面
// @Configuration 是跟 spring有关的配置 运行的时候把它拷贝进来
@Aspect
@Configuration
public class CacheAspect {
    Map<String,Object> cache = new HashMap<>();

    @Around("@annotation(hello.anno.Cache)")
    public Object cache(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("method is called");

        MethodSignature signature = (MethodSignature)joinPoint.getSignature();
        String methodName = signature.getName();
        Object cacheValue = cache.get(methodName);

        if(cacheValue != null){
            System.out.println("cacheValue");
            return cacheValue;
        }else{
            System.out.println("read realValue");
            Object realValue = joinPoint.proceed();
            cache.put(methodName,realValue);
            return realValue;
        }

    }
}

public class CacheAspect {
    @Autowired
    RedisTemplate<String,Object> redisTemplate;

    @Around("@annotation(hello.anno.Cache)")
    public Object cache(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("method is called");

        MethodSignature signature = (MethodSignature)joinPoint.getSignature();
        String methodName = signature.getName();
        Object cacheValue = redisTemplate.opsForValue().get(methodName);

        if(cacheValue != null){
            System.out.println("cacheValue");
            return cacheValue;
        }else{
            System.out.println("read realValue");
            Object realValue = joinPoint.proceed();
            redisTemplate.opsForValue().set(methodName,realValue);
            return realValue;
        }

    }
}

public class LogProxy implements InvocationHandler {
    DataService delegate;

    public LogProxy(DataService delegate) {
        this.delegate = delegate;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(method.getName() + "is start,params is " + Arrays.toString(args));
        Object returnValue = method.invoke(delegate,args);
        System.out.println(method.getName() + "is finised");
        return returnValue;
    }
}

package com.aop.demo;

import java.lang.reflect.Proxy;

public class Main {
    static DataService service = new LogDecorator(new DataServiceImpl());

    static DataService service2 = new DataServiceImpl();

    public static void main(String[] args) {
        // OOP装饰器模式
        System.out.println(service.a(1));
        System.out.println(service.b(1));

        // 动态代理
        DataService dataService = (DataService) Proxy.newProxyInstance(service2.getClass().getClassLoader(), //  接口实现类
                            new Class[]{DataService.class}, // 代理类(必须是接口否则报错)
                            new LogProxy(service2) // 这个方法拦截后被谁处理
                            );

        dataService.a(1);
        dataService.b(2);
    }
}

<!-- https://mvnrepository.com/artifact/cglib/cglib -->
<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

public class DataServiceImpl2 {
    public String a(int i) {
        return UUID.randomUUID().toString();
    }

    public String b(int i) {
        return UUID.randomUUID().toString();
    }
}

public class LogInterceptor implements MethodInterceptor {
    private DataServiceImpl2 delegate;

    public LogInterceptor(DataServiceImpl2 delegate) {
        this.delegate = delegate;
    }

    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println(method.getName() + " is start,params is " + Arrays.toString(objects));
        Object returnValue = method.invoke(delegate,objects);
        System.out.println(method.getName() + " is finised");
        return returnValue;
    }
}

package com.aop.demo;

import net.sf.cglib.proxy.Enhancer;
import java.lang.reflect.Proxy;

public class Main {
    static DataService service = new LogDecorator(new DataServiceImpl());

    // AOP动态代理
    static DataService service2 = new DataServiceImpl();

    public static void main(String[] args) {
        // OOP装饰器模式
        System.out.println(service.a(1));
        System.out.println(service.b(1));

        System.out.println("动态代理-----------------");
        // 动态代理
        DataService dataService = (DataService) Proxy.newProxyInstance(service2.getClass().getClassLoader(), //  接口实现类
                            new Class[]{DataService.class}, // 代理类(必须是接口否则报错)
                            new LogProxy(service2) // 这个方法拦截后被谁处理
                            );

        dataService.a(1);
        dataService.b(2);

        // AOP 动态字节码
        System.out.println("动态字节码-----------------");
        // 动态字节码增强
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(DataServiceImpl2.class);// 设置超类
        enhancer.setCallback(new LogInterceptor(new DataServiceImpl2())); // 设置回调

        // 使用动态字节码增强过的
        DataServiceImpl2 enhancedService = (DataServiceImpl2) enhancer.create();
        enhancedService.a(1);
        enhancedService.b(2);
    }
}

a.b()
b.c()

假如我现在有个 AService 它有100个方法，如何做到调用它的每个方法的时候打印日志，结束的时候打印日志呢？

装饰器模式

AService 它有100个方法
AService
----|a()
----|b()
----|c()
----|d()
----|...
----|xxx()

在进入每个方法的瞬间都看作一个切面 ，每次进入这个方法的一瞬间拦截下来执行某些操作
关注的不是对象方法本身，而是在进入某个方法的一瞬间的这个切面

public interface DataService {
    String a(int i);
    String b(int i);
}

public class DataServiceImpl implements DataService {

    public String a(int i) {
        return UUID.randomUUID().toString();
    }

    public String b(int i) {
        return UUID.randomUUID().toString();
    }
}

package com.aop.demo;

public class Main {
    static DataService service = new DataServiceImpl();

    public static void main(String[] args) {
        System.out.println(service.a(1));
        System.out.println(service.b(1));
    }
}

public class DataServiceImpl implements DataService {
    public String a(int i) {
        System.out.println("a is start");
        System.out.println("a is finish");
        return UUID.randomUUID().toString();
    }

    public String b(int i) {
        System.out.println("b is start");
        System.out.println("b is finish");
        return UUID.randomUUID().toString();
    }
}

public class LogDecorator implements DataService {
    DataService delegate;

    public LogDecorator(DataService delegate) {
        this.delegate = delegate;
    }

    public String a(int i) {
        System.out.println("a is start");
        String value = delegate.a(i);
        System.out.println("a is finish");
        return value;
    }

    public String b(int i) {
        System.out.println("b is start");
        String value = delegate.a(i);
        System.out.println("b is finish");
        return value;
    }
}

public class Main {
    // 额外包了一层，不用改变原有功能
    static DataService service = new LogDecorator(new DataServiceImpl());

    public static void main(String[] args) {
        System.out.println(service.a(1));
        System.out.println(service.b(1));
    }
}

public class CacheDecorator implements DataService {
    private Map<String,String> cache = new HashMap();

    private DataService delegate;

    public CacheDecorator(DataService delegate) {
        this.delegate = delegate;
    }

    public String a(int i) {
        String cacheValue = cache.get("a");
        if(cacheValue == null){
            String realValue = delegate.a(i);
            cache.put("a",realValue);
            return realValue;
        } else {
            return cacheValue;
        }
    }

    public String b(int i) {
        return null;
    }
}

    HTTP
    ^
    |   |
        v
________________
    Controller 只做和HTTP请求相关

    Service 具体的业务逻辑 业务代码

    Dao  只做数据库
________________
    ^
    |   |
        v
    db数据库

搜索 springboot mybatis starter
得到 https://mybatis.org/spring-boot-starter/mybatis-spring-boot-autoconfigure/
找到依赖，添加到pom.xml

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.1</version>
</dependency>

搜索 h2 maven
得到 https://mvnrepository.com/artifact/com.h2database/h2/1.4.200
找到依赖，添加到pom.xml

<!-- https://mvnrepository.com/artifact/com.h2database/h2 -->
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <version>1.4.200</version>
    <!--注释掉这句 -->
    <!--<scope>test</scope>-->
</dependency>

spring.datasource.url=jdbc:h2:file:./target/test
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=org.h2.Driver
mybatis.config-location=classpath:db/mybatis/config.xml

create table user(
  id bigint primary key auto_increment,
  name varchar(100)
);

create table match(
  id bigint primary key auto_increment,
  user_id bigint,
  score int
);

insert into user(id,name) values(1,'AAA');
insert into user(id,name) values(2,'BBB');
insert into user(id,name) values(3,'CCC');


insert into match(id,user_id,score) values(1,1,1000);
insert into match(id,user_id,score) values(2,1,2000);
insert into match(id,user_id,score) values(3,2,500);
insert into match(id,user_id,score) values(4,3,300);

# pom.xml 里添加
<plugin>
    <groupId>org.flywaydb</groupId>
    <artifactId>flyway-maven-plugin</artifactId>
    <version>6.0.7</version>
</plugin>


#配置用户名密码
<plugin>
    <groupId>org.flywaydb</groupId>
    <artifactId>flyway-maven-plugin</artifactId>
    <version>6.0.7</version>
    <configuration>
        <url>jdbc:h2:file:${project.basedir}/target/test</url>
        <user>root</user>
        <password>root</password>
    </configuration>
</plugin>

spring.datasource.url=jdbc:h2:file:.target/test
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=org.h2.Driver
# 配置mybatis
mybatis.config-location=classpath:db/mybatis/config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <setting name="logImpl" value="LOG4J"/>
    </settings>
    <mappers>
        <mapper resource="db/mybatis/MyMapper.xml"/>
    </mappers>
</configuration>

@Mapper
public interface UserMapper {
    @Select("select * from user where id = #{id}")
    public User getUserById(@Param("id") Integer id);
}

public class User {
    private Integer id;
    private String name;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.mybatis.example.BlogMapper">
    <!-- 你是注解方式写的sql -->
</mapper>

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--<settings>-->
        <!--<setting name="logImpl" value="LOG4J"/>-->
    <!--</settings>-->
    <mappers>
        <mapper resource="db/mybatis/MyMapper.xml"/>
        <mapper class="hello.dao.UserMapper"/>
    </mappers>
</configuration>

@Service
public class RankService {
    @Autowired
    private UserMapper userMapper;

    @Autowired
    RankDao rankDao;

    public void doService(){

    }
}

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

<head>
    <title>排行榜</title>
</head>
<body>
<h1>排行榜！</h1>
<table>
    <tr>
        <th>排名</th>
        <th>名字</th>
        <th>分数</th>
    </tr>

   <#list items as item>
       <tr>
           <td>${item?index}</td>
           <td>${item.user.name}</td>
           <td>${item.score}</td>
       </tr>
   </#list>

</table>
</body>

@RequestMapping("/rank2")
public ModelAndView rank2() {
    List<RankItem> items = rankService.doService();
    HashMap<String,Object> model = new HashMap<>();
    model.put("items",items);
    // 自动去 templates目录找 index.ftl
    return new ModelAndView("index",model);
}

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.springframework</groupId>
    <artifactId>gs-spring-boot</artifactId>
    <version>0.1.0</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.5.RELEASE</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

    <properties>
        <java.version>1.8</java.version>
    </properties>


    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

package hello;

import java.util.Arrays;

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

    @Bean
    public CommandLineRunner commandLineRunner(ApplicationContext ctx) {
        return args -> {

            System.out.println("Let's inspect the beans provided by Spring Boot:");

            String[] beanNames = ctx.getBeanDefinitionNames();
            Arrays.sort(beanNames);
            for (String beanName : beanNames) {
                System.out.println(beanName);
            }

        };
    }

}

package hello;

import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;

@RestController
public class HelloController {

    @RequestMapping("/")
    public String index() {
        return "Greetings from Spring Boot!";
    }

}

@RequestMapping("/search")
public String search(@RequestParam String q) {
    //  localhost:8080/search?q=123 时
    System.out.println(q);
    return "search query word is:" + q;
}

原文回答
Yes. In other words, any HTTP request message is allowed to contain a message body, and thus must parse messages with that in mind. Server semantics for GET, however, are restricted such that a body, if any, has no semantic meaning to the request. The requirements on parsing are separate from the requirements on method semantics.

So, yes, you can send a body with GET, and no, it is never useful to do so.

This is part of the layered design of HTTP/1.1 that will become clear again once the spec is partitioned (work in progress).

@RequestMapping("/search2")
public String search2(@RequestParam String q ,
                      @RequestParam(value="charset",required = false) String charset) {
    
    return "search query word is:" + q + ",and charset is :" + charset;
}

// http://localhost:8080/search2?q=123
// search query word is:123,and charset is :null

// http://localhost:8080/search2?q=123&charset=22
// search query word is:123,and charset is :22

package hello;

import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("repos")
public class IssueController {

    // DELETE /repos/:owner/:repo/issues/:issue_number/lock
    @DeleteMapping("/{owner}/{repo}/issues/{issue_number}/lock")
    public String unlock(
            @PathVariable("owner") String owner,
            @PathVariable("repo")String repo,
            @PathVariable("issue_number")String issue_number
            ){
        // 把当前请求路径重的参数 绑定到当前变量中去
        // @PathVariable()
        System.out.println(owner);
        System.out.println(repo);
        System.out.println(issue_number);

        return "owner:" + owner + ",repo:" + repo + ",issue_number:" + issue_number;
    }
}

{
  "title": "Found a bug",
  "body": "I'm having a problem with this.",
  "assignees": [
    "octocat"
  ],
  "milestone": 1,
  "labels": [
    "bug"
  ]
}

@PostMapping("/{owner}/{repo}/issues")
public String create(
        @PathVariable("owner") String owner,
        @PathVariable("repo")String repo,
        @RequestBody Object object
){

    System.out.println(object);
    return "owner:" + owner + ",repo:" + repo + ",request body:" + object;
}

localhost:8080/repos/abc/vue/issues
method 是 post

body 里添加 选择 raw
{
  "title": "Found a bug",
  "body": "I'm having a problem with this.",
  "assignees": [
    "octocat"
  ],
  "milestone": 1,
  "labels": [
    "bug"
  ]
}

raw的 type 如果是 text 结果返回是 415
{
    "timestamp": "2019-11-04T03:21:56.467+0000",
    "status": 415,
    "error": "Unsupported Media Type",
    "message": "Content type 'text/plain;charset=UTF-8' not supported",
    "path": "/repos/abc/vue/issues"
}

              请求
           -------->
client                     server
           <--------
              响应
              
              
受限于底层 实际传输的数据都是 “字节流”

如何区分这些不同类型的数据
必须有一个东西 标识 这些不同的数据是什么类型
media type

Content-Type:application/json

command + n 选择 GsonFormat 
复制你的json字符串
然后ok

@PostMapping("/{owner}/{repo}/issues")
public String create(
        @PathVariable("owner") String owner,
        @PathVariable("repo")String repo,
        @RequestBody MyParam object
){
    System.out.println(object);
    object.getTitle();
    object.getLabels().get(0);
    return "owner:" + owner + ",repo:" + repo + ",request body:" + object;
}

// localhost:8080/repos/demo
// form-data 一般用于参数少的时候
@PostMapping("/demo")
public void postform(
        @RequestParam String name,
        @RequestParam Integer age
){
    System.out.println(name);
    System.out.println(age);
}

// 通过 HttpServletResponse 设置响应的内容
@RequestMapping("search")
public void search(
        HttpServletRequest request,
        HttpServletResponse response
) throws IOException {
    response.setStatus(HttpServletResponse.SC_FORBIDDEN);
    response.getWriter().write("haha");
}

// 通过 @ResponseBody 设置响应为 json
@RequestMapping("search2")
@ResponseBody
public Object search2(){
    Map<String,Object> result = new HashMap<>();
    result.put("name","aaa");
    result.put("age",18);
    return result;
}

              请求
              accept:xml
           -------->
client                     server
           <--------
              响应
              content-type:xml
              
---------------------------------------------

              请求
              accept:json
           -------->
client                     server
           <--------
              响应
              content-type:json

orderDao=com.github.hcsp.OrderDao
orderService=com.github.hcsp.OrderService

public class MyIocContainer {
    public static void main(String[] args) throws IOException {
        Properties properties = new Properties();
        properties.load(MyIocContainer.class.getResourceAsStream("/ioc.properties"));

        Map<String,Object> beans = new HashMap<>();

        // bean的初始化
        properties.forEach((beanName,beanClass)->{
            try {
                Class<?> klass = Class.forName((String) beanClass);
                Object beanInstance = klass.getConstructor().newInstance();
                beans.put((String)beanName,beanInstance);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        });

        // 装配依赖
        beans.forEach((beanName,beanInstance)-> dependencyInject(beanName,beanInstance,beans));

        OrderService orderService = (OrderService) beans.get("orderService");
        OrderDao orderDao = (OrderDao) beans.get("orderDao");
        System.out.println();
    }

    private static void dependencyInject(String beanName, Object beanInstance, Map<String, Object> beans) {
        // 把所有的 field扫描一遍
        List<Field> fieldsToBeAutowried = Stream.of(beanInstance.getClass().getDeclaredFields())
                .filter(field -> field.getAnnotation(Autowired.class) != null)
                .collect(Collectors.toList());
        // 过滤带有 @Autowired 注解的过滤出来

        fieldsToBeAutowried.forEach(field -> {
            try {
                String fieldName = field.getName();
                Object dependencyBeanInstance = beans.get(fieldName);
                field.setAccessible(true);
                field.set(beanInstance,dependencyBeanInstance);
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            }
        });
    }
}

public class OrderService {
    @Autowired
    private OrderDao orderDao;

    // ...
}


public class OrderDao {
    @Autowired
    private OrderService orderService;
    // ...
}

// 循环引用，不会重复产生对象。

# 循环依赖出现的问题是因为 ，构造器注入
public class OrderDao {
    private OrderService orderService;

    @Autowired
    public OrderDao(OrderService orderService) {
        this.orderService = orderService;
    }
    // ...
}


public class OrderService {
    private OrderDao orderDao;

    public OrderService(OrderDao orderDao) {
        this.orderDao = orderDao;
    }
    // ...
}


这是一个在初始化过程中的循环依赖，是无法解决的

public class OrderDao {
    // 这个值 随着运行的时间而改变叫做“有状态”
    private int count;
    @Autowired
    private OrderService orderService;

    public void select(){
        count++;
        System.out.println("select");
    }
}


// 无状态代表。在整个生命周期里，它里面的某种状态 比如  orderService的引用 始终是一个

public class OrderService {
    private OrderDao orderDao;

    @Autowired
    public OrderService(OrderDao orderDao) {
        this.orderDao = orderDao;
    }

    public void doSomething(){
        System.out.println(orderDao);
        orderDao.select();
    }
}

public class OrderService {
    @Autowired
    private OrderDao orderDao;

    public void doSomething(){
        System.out.println(orderDao);
        orderDao.select();
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>spring_di_ioc</groupId>
    <artifactId>spring_di_ioc_demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <repositories>
        <repository>
            <id>alimaven</id>
            <name>aliyun maven</name>
            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
        </repository>
    </repositories>
</project>

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>

public class SpringMain {
    public static void main(String[] args) {
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:config.xml");
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- bean definitions here -->

</beans>

public class OrderDao {
    public void select(){
        System.out.println("select");
    }
}

public class OrderService {
    // 依赖另一个模块
    private OrderDao orderDao;

    public void doSomething(){
        orderDao.select();
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- bean definitions here -->

    <bean id="orderDao" class="com.github.hcsp.OrderDao"/>
    <bean id="orderService" class="com.github.hcsp.OrderService"/>
</beans>

public class SpringMain {
    public static void main(String[] args) {
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:config.xml");

        // 此行断点
        OrderService orderService = (OrderService) beanFactory.getBean("orderService");
        System.out.println(orderService);
        
        orderService.doSomething();
    }
}

public class OrderService {
    // 三种注解告诉 java 依赖内容
    // @Autowired 自动装配
    // @Resource
    // @Inject
    // private OrderDao orderDao;

    @Autowired
    private OrderDao orderDao;

    public void doSomething(){
        System.out.println(orderDao);
        orderDao.select();
    }
}

<?xml version = "1.0" encoding = "UTF-8"?>

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xmlns:context = "http://www.springframework.org/schema/context"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <!-- 添加这句：意思是 请你看到注解的时候帮我留意以下 -->
   <context:annotation-config/>
   <!-- bean definitions go here -->

</beans>

debug  你发现运行的时候
根据 config.xml 创建了 两个 bean实例 OrderService 和 OrderDao
而难能可贵的是
 OrderService 依赖的 OrderDao 
跟上面的 OrderDao 是同一个 (单例)

// OrderService 依赖了 OrderDao
public class OrderService {
    @Autowired
    private OrderDao orderDao;

    public void doSomething(){
        System.out.println(orderDao);
        orderDao.select();
    }
}

// orderDao 一开始是 null
// 虽然声明了依赖但全部都是 null
// 在一个魔法一般的过程之后
// spring容器让他们所有的依赖都变成正确的依赖
// 这就是依赖注入

以前我们写程序要这样 手工的去创建对象
OrderService orderService = new OrderService();
orderService.select();
// 我们控制了对象的所有装配和运行
// 这是完全由人去控制 装配

// 而控制反转呢？
就是你通过声明 A 依赖了 B ，此时天上掉下来一个阿拉丁神灯。他挥了下魔法棒 biu 的一声，这些东西全部自动装配好了，变成了一个可以用的容器

这就是控制反转的过程，你不需要控制 它们所有的依赖 和装配的进行
你只需要声明 它们 谁依赖了谁。有人会自动的帮你进行装配

这就是 控制反转

这个挥魔法棒的人 叫做—— Spring 容器

public interface SqlSessionFactory {

  SqlSession openSession();

  SqlSession openSession(boolean autoCommit);

  SqlSession openSession(Connection connection);

  SqlSession openSession(TransactionIsolationLevel level);

  SqlSession openSession(ExecutorType execType);

  SqlSession openSession(ExecutorType execType, boolean autoCommit);

  SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level);

  SqlSession openSession(ExecutorType execType, Connection connection);

  Configuration getConfiguration();

}

public class ErrorContext {

  private static final ThreadLocal<ErrorContext> LOCAL = new ThreadLocal<>();
  
  // ...

  // 私有方法，意味着外部无法使用这个构造器创建实例
  private ErrorContext() {
  }


  public static ErrorContext instance() {
    ErrorContext context = LOCAL.get();
    // 保证了 context 只有一个
    if (context == null) {
      context = new ErrorContext();
      LOCAL.set(context);
    }
    return context;
  }

  // ...

}

// 你可以这样
public class MySingleton {

    private static final MySingleton INSTANCE = new MySingleton();

    private MySingleton(){}

    public static MySingleton getInstance(){
        return INSTANCE;
    }
}

// 也可以这样,但是多线程下可能有问题
public class MySingleton {

    private static MySingleton INSTANCE = null;

    private MySingleton(){}

    public static MySingleton getInstance(){
        if(INSTANCE == null){
            INSTANCE = new MySingleton();
        }
        return INSTANCE;
    }
}

// 还可以这样 使用枚举
public enum MySingleton {

    INSTANCE;

    public void dosomething(){

    }
}

// xml方式
public void deleteUserById(Integer id) {
    try (SqlSession session = sqlSessionFactory.openSession(true)) {
        session.delete("MyMapper.deleteUserById", id);
    }
}

// 代理模式
interface UserMapper{
    @Delete("delete from user where id =#{id}")
    void deleteUserById(@Param("id") Integer id);
}
public void deleteUserById2(Integer id) {
    try (SqlSession session = sqlSessionFactory.openSession(true)) {
    // 此行断点，进去就可以看到 MapperProxyFactory 就是一种代理模式
        UserMapper userMapper = session.getMapper(UserMapper.class);
        userMapper.deleteUserById(id);
    }
}

public class CachingExecutor implements Executor {

  private final Executor delegate;
  @Override
  public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
      throws SQLException {
    Cache cache = ms.getCache();
    if (cache != null) {
      flushCacheIfRequired(ms);
      if (ms.isUseCache() && resultHandler == null) {
        ensureNoOutParams(ms, boundSql);
        @SuppressWarnings("unchecked")
        List<E> list = (List<E>) tcm.getObject(cache, key);
        if (list == null) {
          list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
          tcm.putObject(cache, key, list); // issue #578 and #116
        }
        return list;
      }
    }
    // 委托查询
    return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }
  
  // ...
}

@Override
public int update(MappedStatement ms, Object parameter) throws SQLException {
    ErrorContext.instance().resource(ms.getResource()).activity("executing an update").object(ms.getId());
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    clearLocalCache();
    return doUpdate(ms, parameter);
}

public interface Log {

  boolean isDebugEnabled();

  boolean isTraceEnabled();

  void error(String s, Throwable e);

  void error(String s);

  void debug(String s);

  void trace(String s);

  void warn(String s);

}

# 如果你这样 ，name 没有时会报错
<select id="selectUserByName" resultType="User">
    select * from user
    where
    <if test="name != null">
        name like #{name}
    </if>
</select>

# 它会拼成这样
# select * from user where

# 你可以这样
<select id="selectUserByName" resultType="User">
    select * from user
    <if test="name != null">
        where name like #{name}
    </if>
</select>

<select id="chooseUser" resultType="User">
    select * from user
    <choose>
        <when test="name =='wangwu'">
            where name = 'wangwu'
        </when>
        <otherwise>
            where name = 'zhangsan'
        </otherwise>
    </choose>
</select>

// 这里的坑在这
<when test="name =='wangwu'"> 

不要写成这样 
不要写成这样 
不要写成这样 
<when test="name ==wangwu">
这样它会在运行时把 wangwu 当作查询User的字段而不是字符串

<select id="findActiveBlogLike" resultType="Blog">
    select * from Blog
    where
    <if test="state != null">
        name like #{state}
    </if>
</select>

如果条件都state = null,不满足就会导致语法错误
SELECT * FROM Blog
WHERE

正确的做法是
<select id="findActiveBlogLike"
     resultType="Blog">
  SELECT * FROM BLOG
  <where>
    <if test="state != null">
         state = #{state}
    </if>
    <if test="title != null">
        AND title like #{title}
    </if>
    <if test="author != null and author.name != null">
        AND author_name like #{author.name}
    </if>
  </where>
</select>

如果条件不满足它就没有where

<update id="updateAuthorIfNecessary">
  update Author
    <set>
      <if test="username != null">username=#{username},</if>
      <if test="password != null">password=#{password},</if>
      <if test="email != null">email=#{email},</if>
      <if test="bio != null">bio=#{bio}</if>
    </set>
  where id=#{id}
</update>

// UserMapper.xml
// item循环的对象
// index索引
// collection 结果集
<select id="selectIds" resultType="User">
    select *
    from user where id in
    <foreach item="item" index="index" collection="ids"
             open="(" separator="," close=")">
      #{item}
    </foreach>
</select>

// Sql.java
Map<String,Object> param = new HashMap<>();
param.put("ids", Arrays.asList(1,2));
List<User> resUser = session.selectList("com.sql.xml.UserMapper.selectIds",param);
System.out.println(resUser);

@Update({"<script>",
  "update Author",
  "  <set>",
  "    <if test='username != null'>username=#{username},</if>",
  "    <if test='password != null'>password=#{password},</if>",
  "    <if test='email != null'>email=#{email},</if>",
  "    <if test='bio != null'>bio=#{bio}</if>",
  "  </set>",
  "where id=#{id}",
  "</script>"})
void updateAuthorValues(Author author);