@Component:组件 没有明确规定其角色，作用在类级别上声明当前类为一个业务组件，被Spring Ioc 容器维护;

@Service:在业务逻辑层（Service 层）类级别进行声明;

@Repository:在数据访问层(dao 层) 类级别声明;

@Controller:在展现层(MVC) 使用 标注当前类为一个控制器

@AutoWired:Spring 官方提供注解
    
@Inject:JSR-330 提供注解（标准制定方）
    
@Resource:JSR-250 提供注解

@Configuration:作用与类上，将当前类声明为一个配置类，相当于一个xml 配置文件
    
@ComponentScan:自动扫描指定包下标注有@Repository,@Service,@Controller
    
@Component:注解的类并由Ioc 容器进行实例化和维护
    
@Bean:作用于方法上,相当于xml 文件中<bean> 声明当前方法返回值为一个bean。可用于第三方组件的实例化（主要作用，因为第三方组件的源码无法改变，没办法通过在类上加@Resource和@AutoWried的方式注入）
    
@Value:获取properties 文件指定key value值

  <dependencies>
    <!--spring的依赖坐标-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.3.RELEASE</version>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <!-- 指定Maven编译的JDK版本和编码-->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>2.3.2</version>
        <configuration>
          <!--源代码使用的JDK版本-->
          <source>1.8</source>
          <target>1.8</target>
          <encoding>utf-8</encoding>
        </configuration>
      </plugin>
    </plugins>
  </build>

@Repository
public class UserDao {

    public void test(){
        System.out.println("UserDao test...");
    }
}

@Service
public class UserService {

    @Resource
    private UserDao userDao;

    public void test(){
        System.out.println("UserService test...");

        userDao.test();
    }
}

@Configuration //声明当前类是一个配置类，相当于xml配置文件
@ComponentScan("com.msb")//扫描器，定义扫描的包范围
public class IOCConfig {
}

public class Starter {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(IOCConfig.class);
        //得到需要被实例化的对象
        UserService service = context.getBean(UserService.class);
		//调用Bean对象的方法
        service.test();

    }
}

//不添加实例化注解
public class AccountDao {

    public void test(){
        System.out.println("AccountDao test...");
    }
}

@Configuration //声明当前类是一个配置类，相当于xml配置文件
@ComponentScan("com.msb")//扫描器，定义扫描的包范围
public class IOCConfig02 {

    /**
     * 实例化bean对象
     * @Bean 将方法的返回值（bean对象）交给IOC进行维护
     * 可用于第三方组件的实例化（主要作用，因为第三方组件的源码无法改变，没办法通过在类上加@Resource和@AutoWried的方式注入）
     */
    @Bean
    public AccountDao accountDao(){
        return new AccountDao();
    }
}

public class Starter02 {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(IOCConfig02.class);
        //得到需要被实例化的对象
        AccountService accountService = (AccountService) context.getBean("accountService");

        accountService.test();

    }
}

# user.properties
user.userName=admin
user.password=admin

# jdbc.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/hr?useUnicode=true&characterEncoding=utf8
jdbc.username=root
jdbc.password=root

@Configuration //声明当前类是一个配置类，相当于xml配置文件
@ComponentScan("com.msb")//扫描器，定义扫描的包范围
//加载配置文件，声明在设置过@Configuration注解的配置类上
@PropertySource(value = {"classpath:db.properties","classpath:user.properties"})
public class IOCConfig03 {

    //通过@Value注解获取指定key的值， @Value("${key}"),声明在字段名上
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.username}")
    private String name;
    @Value("${jdbc.password}")
    private String pwd;

    @Value("${user.userName}")
    private String userName;
    @Value("${user.password}")
    private String password;

    public void print(){
        System.out.println("driver:"+driver+",url:"+url);
        System.out.println("name:"+name+",pwd:"+pwd);
        System.out.println("userName:"+userName+",password:"+password);
    }
}

@Service
public class UserService {

    @Resource
    private UserDao userDao;

    public void test(){
        System.out.println("UserService test...");

        userDao.test();
    }
}

//使用自定义组合注解，结合了元注解+@Configuration+@ComponentScan
@MyComScan("com.msb")
//加载配置文件，声明在设置过@Configuration注解的配置类上
@PropertySource(value = {"classpath:db.properties","classpath:user.properties"})
public class IOCConfig04 {

    //通过@Value注解获取指定key的值， @Value("${key}"),声明在字段名上
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.username}")
    private String name;
    @Value("${jdbc.password}")
    private String pwd;

    @Value("${user.userName}")
    private String userName;
    @Value("${user.password}")
    private String password;

    public void print(){
        System.out.println("driver:"+driver+",url:"+url);
        System.out.println("name:"+name+",pwd:"+pwd);
        System.out.println("userName:"+userName+",password:"+password);
    }
}

public class Starter04 {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(IOCConfig04.class);
        //得到需要被实例化的对象
        AccountService accountService = (AccountService) context.getBean("accountService");

        //得到IOCConfig03对象
        IOCConfig03 config03 = (IOCConfig03) context.getBean(IOCConfig03.class);
        config03.print();


    }
}

<dependencies>
    <!-- spring web -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>5.2.4.RELEASE</version>
    </dependency>
    <!-- spring mvc -->
    <dependency>
    <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.4.RELEASE</version>
    </dependency>
    <!-- web servlet -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.0.1</version>
    </dependency>
  </dependencies>
  <build>
    <finalName>springmvc5x</finalName>

    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>2.3.2</version>
        <configuration>
          <!-- 指定Maven编译的JDK版本和编码 -->
          <source>1.8</source>
          <target>1.8</target>
          <encoding>utf-8</encoding>
        </configuration>
      </plugin>
      <plugin>
        <groupId>org.eclipse.jetty</groupId>
        <artifactId>jetty-maven-plugin</artifactId>
        <version>9.4.27.v20200227</version>
      </plugin>
    </plugins>

  </build>

@Controller
public class UserController {

    @RequestMapping("/hello")
    public String index(){
        return "index";
    }
}

@Configuration//当前类是配置类
@EnableWebMvc//启用mvc环境
@ComponentScan("com.msb")//扫描包范围
public class MvcConfig extends WebMvcConfigurationSupport {

    /**
     * 配置jsp视图解析器
     */
    @Bean//方法的返回值会交给IOC容器进行实例化
    public InternalResourceViewResolver viewResolver() {
        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
        //设置视图的前缀
        viewResolver.setPrefix("/WEB-INF/views/");
        //设置视图的后缀
        viewResolver.setSuffix(".jsp");
        return viewResolver;
    }

    /**
     * 如果需要使用拦截器或者其他相关的配置，则需要继承父类WebMvcConfigurerAdapter
     */
    /**
     * 设置拦截器
     */
    @Override
    protected void addInterceptors(InterceptorRegistry registry) {
        super.addInterceptors(registry);
    }
    /**
     * 设置静态资源路径
     */
    @Override
    public HandlerMapping defaultServletHandlerMapping() {
        return super.defaultServletHandlerMapping();
    }
}

/**
 * 定义类实现WebApplicationInitializer 接口
 *  当容器启动时，会自动执行onStartup 方法
 *
 *   加载springMVC的配置类
 */
public class WebInitializer implements WebApplicationInitializer {
    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        System.out.println("容器正在启动...");

        //基于Java配置类得到上下文环境
        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
        //注册mvc的配置类
        context.register(MvcConfig.class);
        //设置servletContext对象（注册servletContext上下文信息）
        context.setServletContext(servletContext);
        //设置中央控制器
        ServletRegistration.Dynamic dispatcher = servletContext.addServlet("dispatcher", new DispatcherServlet(context));
        //设置需要拦截的路径
        dispatcher.addMapping("/");//拦截所有的资源路径
        //设置容器启动时自动加载servlet（中央控制器）
        dispatcher.setLoadOnStartup(1);
    }
}

	/**
     * 如果需要使用拦截器或者其他相关的配置，则需要继承父类WebMvcConfigurerAdapter
     */
    /**
     * 设置拦截器
     */
    @Override
    protected void addInterceptors(InterceptorRegistry registry) {
        super.addInterceptors(registry);
    }
    /**
     * 设置静态资源路径
     */
    @Override
    public HandlerMapping defaultServletHandlerMapping() {
        return super.defaultServletHandlerMapping();
    }

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.2.RELEASE</version>
</parent>
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

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

@Controller
public class HelloController {
    @RequestMapping("hello")
    @ResponseBody
    public String hello(){
    	return "Hello Spring Boot";
    }
}

@SpringBootApplication
public class Starter {

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

@SpringBootApplication
public class Starter extends SpringBootServletInitializer {

    public static void main(String[] args) {
        SpringApplication springApplication=new SpringApplication(Starter.class);
        // 设置banner 图标关闭
        springApplication.setBannerMode(Banner.Mode.OFF);
        springApplication.run();
    }
}

# SpringBoot的全局配置文件名必须为:application，可以是.properties 或 .yml文件，需要将配置文件设置到src/main/resources资源目录下
# 键值对，例如：键=值；配置文件中key是固定的，值根据需求自定义
## 项目启动端口号配置
server.port=8989
## 项目访问上下文路径
server.servlet-path=/mvc
## 数据源配置
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/hr?useUnicode=true&characterEncoding=utf8
spring.datasource.username=root
spring.datasource.password=root

# SpringBoot的全局配置文件名必须为:application，可以是.properties 或 .yml文件，需要将配置文件设置到src/main/resources资源目录下

# 设置端口
server:
  port: 8989
  servlet:
    context-path: /sp

## 数据源配置
spring:
	datasource:
        type: com.mchange.v2.c3p0.ComboPooledDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://127.0.0.1:3306/hr
        username: root
        password: root

    <!--web环境-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

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

	<!--打war包时 忽略内置tomcat-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-tomcat</artifactId>
      <scope>provided</scope>
    </dependency>

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

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

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

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <!--
    父类项目统一对项目依赖版本统一控制!
    -->
    <version>2.2.2.RELEASE</version>
</parent>

@ConditionalOnBean // 当给定的在bean存在时,则实例化当前Bean
@ConditionalOnMissingBean // 当给定的在bean不存在时,则实例化当前Bean
@ConditionalOnClass // 当给定的类名在类路径上存在，则实例化当前Bean
@ConditionalOnMissingClass // 当给定的类名在类路径上不存在，则实例化当前Bean

	Spring Boot通过maven中的starter导入了所需场景下的jar包，并通过主启动类上的@SpringBootApplication中的@EnableAutoConfiguration读取了类路径下的META-INF/spring.factories下EnableAutoConfiguration的配置类，这些配置类使用@ConditionalOnClass来标注，根据@ConditionalOnClass标注的约束条件来引入自动化的环境配置。

## 环境选择配置
spring:
	profiles:
		active: prod

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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Starter {
	private static Logger logger = LoggerFactory.getLogger(Starter.class);
	public static void main(String[] args) {
		logger.info("SpringBoot 应用开始启动...");
		SpringApplication.run(Starter.class);
	}
}

# 设置日志输出格式
logging:
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger- %msg%n"
    level: debug
  file:
    path: "."
    name: "springboot.log"

  # thymeleaf 配置
  thymeleaf:
    # thymeleaf 默认的加载路径（resource目录下的html目录中）
    prefix: classpath:/html/
    ## 关闭thymeleaf 页面缓存
    cache: false

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1 th:text="${msg}"></h1>
</body>
</html>

spring:
 #自定义静态资源的路径（"classpath:/META-INF/resources/", "classpath:/resources/", "classpath:/static/", "classpath:/public/"）
  resources:
    # 修改默认的静态资源目录，多个路径之间用逗号隔开
    static-locations: classpath:/static/,classpath:/public/,classpath:/os/

    <!--打war包时 忽略内置tomcat-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-tomcat</artifactId>
      <scope>provided</scope>
    </dependency>

 <build>
    <!--打war包，war包的名字-->
    <finalName>springboot</finalName>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>

@SpringBootApplication
public class Starter extends SpringBootServletInitializer {

    //使用日志
    private static org.slf4j.Logger Logger = LoggerFactory.getLogger(Starter.class);

    public static void main(String[] args) {
        SpringApplication.run(Starter.class);
        Logger.info("启用应用...");
    
    }

    /**
     * 添加容器启动加载文件(类似于读取web.xml)
     * 通过继承SpringBootServletInitializer 类并重写configure方法来实现
     * 在部署项目时指定外部tomcat 读取项目入口方法。
     **/
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(Starter.class);
    }
}

public interface UserMapper {
    
    //通过用户id查询用户对象
    User queryUserById(Integer id);

}

<?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="com.msb.springboot.dao.UserMapper">

    <!--通过用户id查询用户-->
    <select id="queryUserById" parameterType="int" resultType="com.msb.springboot.po.User">
        select * from t_user where id=#{id}
    </select>

</mapper>

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

    /**
     * 通过用户id查询用户对象
     * @param id
     * @return
     */
    public User queryUserById(Integer id){
        return userMapper.queryUserById(id);
    }

}

//@Controller
@RestController//如果类上设置了该注解，表示该类中所有的方法返回的都是（json）格式的字符串
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * 通过用户id查询用户对象
     * @param id
     * @return
     */
    @GetMapping("/user/{id}")
    public User queryUserById(@PathVariable Integer id){
        return userService.queryUserById(id);
    }

}

public interface UserMapper {
   
    //添加用户
    int addUser(User user);

}

<?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="com.msb.springboot.dao.UserMapper">

    <!--添加用户-->
    <insert id="addUser" parameterType="com.msb.springboot.po.User">
        insert into
            t_user(user_name,user_pwd)
        values
            (#{userName},#{userPwd})
    </insert>

</mapper>

 <!--commons-lang3工具包-->
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-lang3</artifactId>
    </dependency>

package com.msb.springboot.util;

import com.msb.springboot.exception.ParamsException;
import com.mysql.cj.exceptions.SSLParamsException;

public class AssertUtil {

    /**
     * 数据校验
     *      满足条件，则抛出异常
     * @param flag
     * @param msg
     */
    public static void isTrue(boolean flag, String msg) {
        //判断flag的值是否为空，如果为true，则抛出异常·
        if (flag) {
            throw new ParamsException(msg);
        }
    }
}

package com.msb.springboot.exception;

public class ParamsException extends RuntimeException {
    private Integer code = 500;
    private String msg="参数异常";

    public ParamsException(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public ParamsException(){}

    public ParamsException(String msg){
        this.msg = msg;
    }


    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

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

    /**
     * 添加用户
     *      1.用户名非空校验
     *      2.密码非空
     *      3.用户名唯一
     *      4.添加后返回受影响行数大于0
     * @param user
     */
    @Transactional(propagation = Propagation.REQUIRED)
    public void addUser(User user){
        //用户名 非空判断
        AssertUtil.isTrue(StringUtils.isBlank(user.getUserName()),"用户名称不能为空");
        //用户密码 非空判断
        AssertUtil.isTrue(StringUtils.isBlank(user.getUserPwd()),"用户密码不能为空");
        //通过用户名查询用户对象
        User temp = userMapper.queryUserByName(user.getUserName());
        //判断用户名唯一
        AssertUtil.isTrue(null!=temp,"用户已存在，请重新输入");
        //执行添加操作，判断受影响的行数
        AssertUtil.isTrue(userMapper.addUser(user)!=1,"用户添加失败");
    }

}

package com.msb.springboot.model;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;

/**
 * 用来封装返回的数据
 */
@ApiModel(value = "结果封装对象")
public class ResultInfo {
    @ApiModelProperty(value = "状态码",example = "200")
    private Integer code=200;//状态码 默认 200=成功 500=失败
    @ApiModelProperty(value = "提示信息")
    private String msg="操作成功";//提示信息,默认提示 操作成功
    @ApiModelProperty(value = "返回对象")
    private Object result;//返回结果

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public Object getResult() {
        return result;
    }

    public void setResult(Object result) {
        this.result = result;
    }
}

//@Controller
@RestController//如果类上设置了该注解，表示该类中所有的方法返回的都是（json）格式的字符串
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * 添加用户
     * @param user
     * @return
     */
    @PostMapping("user")
    public ResultInfo addUser(@RequestBody User user){
        ResultInfo resultInfo = new ResultInfo();

        //调用service层的添加方法
        userService.addUser(user);

        try{
            //调用service层的添加方法
            userService.addUser(user);
        }catch (ParamsException p){
            resultInfo.setCode(p.getCode());
            resultInfo.setMsg(p.getMsg());
        } catch (Exception e){
            resultInfo.setCode(500);
            resultInfo.setMsg("用户添加失败");
        }

        return resultInfo;
    }

}

public interface UserMapper {
    
    //修改用户
    int updateUser(User user);

}

<?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="com.msb.springboot.dao.UserMapper">

    <!--修改用户-->
    <update id="updateUser" parameterType="com.msb.springboot.po.User">
        update
            t_user
        set
            user_name=#{userName},user_pwd=#{userPwd}
        where
            id = #{id}
    </update>

</mapper>

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

    /**
     * 修改用户
     *      1.用户名非空校验
     *      2.密码非空
     *      3.用户名唯一
     *          通过用户名查询用户对象，用户对象不存在 或 用户对象是当前修改记录本身
     *      4.修改后返回受影响行数大于0
     * @param user
     */
    public User updateUser(User user){
        //用户名 非空判断
        AssertUtil.isTrue(StringUtils.isBlank(user.getUserName()),"用户名称不能为空");
        //用户密码 非空判断
        AssertUtil.isTrue(StringUtils.isBlank(user.getUserPwd()),"用户密码不能为空");
        //通过用户名查询用户对象
        User temp = userMapper.queryUserByName(user.getUserName());
        //如果用户对象不为空且用户id不一致
        AssertUtil.isTrue(null!=temp && !(user.getId().equals(temp.getId())),"用户名已存在，请重新输入");
        //执行修改操作，判断受影响的行数
        AssertUtil.isTrue(userMapper.updateUser(user)!=1,"用户添加失败");

        return user;
    }

}

//@Controller
@RestController//如果类上设置了该注解，表示该类中所有的方法返回的都是（json）格式的字符串
public class UserController {

    @Autowired
    private UserService userService;

/**
     * 修改用户
     * @param user
     * @return
     */
    @PutMapping("user")
    public ResultInfo updateUser(@RequestBody User user){
        ResultInfo resultInfo = new ResultInfo();

        //调用service层的添加方法
        userService.updateUser(user);
        try{
            //调用service层的添加方法
            userService.updateUser(user);
        }catch (ParamsException p){
            resultInfo.setCode(p.getCode());
            resultInfo.setMsg(p.getMsg());
        } catch (Exception e){
            resultInfo.setCode(500);
            resultInfo.setMsg("用户修改失败");
            e.printStackTrace();
        }

        return resultInfo;
    }

}

public interface UserMapper {
    
    //删除用户
    int deleteUser(Integer id);

}

<?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="com.msb.springboot.dao.UserMapper">

    <!--删除用户-->
    <delete id="deleteUser" parameterType="int">
        delete  from t_user where id = #{id}
    </delete>


</mapper>

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

     /**
     * 删除用户
     *      1. id是否为空且用户对象存在
     * @param id
     */
    @Transactional(propagation = Propagation.REQUIRED)
    @CacheEvict(value = "users",key = "#id")
    public void deleteUser(Integer id){
        //判断id是否为空且用户对象存在
        AssertUtil.isTrue(null==id &&userMapper.queryUserById(id)==null,"待删除记录不存在");
        //执行删除操作，判断受影响的行数
        AssertUtil.isTrue(userMapper.deleteUser(id)!=1,"用户删除失败");
    }

}

//@Controller
@RestController//如果类上设置了该注解，表示该类中所有的方法返回的都是（json）格式的字符串
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * 删除用户
     * @param userId
     * @return
     */
    @DeleteMapping("user/{userId}")
    public ResultInfo deleteUser(@PathVariable Integer userId){
        ResultInfo resultInfo = new ResultInfo();

        //调用service层的添加方法
        userService.deleteUser(userId);

        try{
            //调用service层的添加方法
            userService.deleteUser(userId);
        }catch (ParamsException p){
            resultInfo.setCode(p.getCode());
            resultInfo.setMsg(p.getMsg());
        } catch (Exception e){
            resultInfo.setCode(500);
            resultInfo.setMsg("用户删除失败");
        }

        return resultInfo;
    }

}

package com.msb.springboot.query;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;

@ApiModel(value = "用户查询对象")
public class UserQuery {
    /* 分页参数 */
    @ApiModelProperty(value = "当前页",example = "1")
    private Integer pageNum=1;//当前页
    @ApiModelProperty(value = "每页显示的记录数",example = "10")
    private Integer pageSize=10;//每页显示的记录数

    /* 条件参数 */
    @ApiModelProperty(value = "用户名")
    private String userName;//查询条件：用户名

    public Integer getPageNum() {
        return pageNum;
    }

    public void setPageNum(Integer pageNum) {
        this.pageNum = pageNum;
    }

    public Integer getPageSize() {
        return pageSize;
    }

    public void setPageSize(Integer pageSize) {
        this.pageSize = pageSize;
    }

    public String getUserName() {
        return userName;
    }

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

public interface UserMapper {
   
    //分页查询
    public List<User> selectByParams(UserQuery userQuery);

}

    <!--条件查询用户列表-->
    <select id="selectByParams" parameterType="com.msb.springboot.query.UserQuery" resultType="com.msb.springboot.po.User">
        select
            *
        from
            t_user
        <where>
            <if test="null !=userName and userName !=''">
                and user_name like concat('%',#{userName},'%')
            </if>
        </where>
    </select>

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

    /**
     * 分页条件查询用户列表
     * @param userQuery
     * @return
     */
    @Cacheable(value = "users",key = "#userQuery.userName+'-'+#userQuery.pageNum+'-'+#userQuery.pageSize")
    public PageInfo<User> selectByParams(UserQuery userQuery){
        //开启分页
        PageHelper.startPage(userQuery.getPageNum(),userQuery.getPageSize());
        //返回分页结果
        return new PageInfo<User>(userMapper.selectByParams(userQuery));
    }

}

//@Controller
@RestController//如果类上设置了该注解，表示该类中所有的方法返回的都是（json）格式的字符串
public class UserController {

    @Autowired
    private UserService userService;

	/**
     * 分页条件查询用户列表
     * @param userQuery
     * @return
     */
    @GetMapping("user/list")
    public PageInfo<User> selectByParams(UserQuery userQuery){
        return userService.selectByParams(userQuery);
    }

}

@Api：用在请求的类上，说明该类的作用
	tags="说明该类的作用"

@Api(tags="APP用户注册Controller")

@ApiOperation："用在请求的方法上，说明方法的作用"
    value="说明方法的作用"
    notes="方法的备注说明"

@ApiOperation(value="用户注册",notes="手机号、密码都是必输项，年龄随边填，但必须是数字")

@ApiImplicitParams：用在请求的方法上，包含一组参数说明
	@ApiImplicitParam：用在 @ApiImplicitParams 注解中，指定一个请求参数的配置信息
        name：参数名
        value：参数的汉字说明、解释
        required：参数是否必须传
        paramType：参数放在哪个地方
            · header --> 请求参数的获取：@RequestHeader
            · query --> 请求参数的获取：@RequestParam
            · path（用于restful接口）-->请求参数的获取:@PathVariable
            · body（不常用）
            · form（不常用）
        dataType：参数类型，默认String，其它值dataType="Integer"
        defaultValue：参数的默认值

@ApiImplicitParams({
    @ApiImplicitParam(name="mobile",value="手机号",required=true,paramType="form"),
    @ApiImplicitParam(name="password",value="密码",required=true,paramType="form"),
    @ApiImplicitParam(name="age",value="年龄",required=true,paramType="form",dataType="Integer")
})

@ApiResponses：用于请求的方法上，表示一组响应
	@ApiResponse：用在@ApiResponses中，一般用于表达一个错误的响应信息
        code：数字，例如400
        message：信息，例如"请求参数没填好"
        response：抛出异常的类

@ApiOperation(value = "select请求",notes = "多个参数，多种的查询参数类型")
    @ApiResponses({
        @ApiResponse(code=400,message="请求参数没填好"),
        @ApiResponse(code=404,message="请求路径没有或页面跳转路径不对")
})

@ApiModel：用于响应类上，表示一个返回响应数据的信息（这种一般用在post创建的时候，使用@RequestBody这样的场景，请求参数无法使用@ApiImplicitParam注解进行描述的时候）
	@ApiModelProperty：用在属性上，描述响应类的属性

@ApiModel(description= "返回响应数据")
public class RestMessage implements Serializable{
    @ApiModelProperty(value = "是否成功")
    private boolean success=true;
    @ApiModelProperty(value = "返回对象")
    private Object data;
    @ApiModelProperty(value = "错误编号")
    private Integer errCode;
    @ApiModelProperty(value = "错误信息")
    private String message;
    /* getter/setter */
}

	 /**
     * 通过用户名查询用户对象
     * @param userName
     * @return
     */
    @GetMapping("/user/name/{userName}")
    @ApiOperation(value = "通过用户名称查询用户对象")
    @ApiImplicitParam(name = "userName",value = "用户名称",required = true,paramType = "path")
    public User getUserService(@PathVariable String userName) {
        System.out.println("用户查询...test121123");
        return userService.queryUserByName(userName);
    }

    /**
     * 通过用户id查询用户对象
     * @param id
     * @return
     */
    @GetMapping("/user/{id}")
    @ApiOperation(value = "通过用户id查询用户对象")
    @ApiImplicitParam(name = "id",value = "用户id",required = true,paramType = "path")
    public User queryUserById(@PathVariable Integer id){
        return userService.queryUserById(id);
    }

    /**
     * 添加用户
     * @param user
     * @return
     */
    @PostMapping("user")
    @ApiOperation(value = "添加用户")
    @ApiImplicitParam(name = "user", value = "用户实体类")
    public ResultInfo addUser(@RequestBody User user){
        ResultInfo resultInfo = new ResultInfo();

        //调用service层的添加方法
        userService.addUser(user);

        /*try{
            //调用service层的添加方法
            userService.addUser(user);
        }catch (ParamsException p){
            resultInfo.setCode(p.getCode());
            resultInfo.setMsg(p.getMsg());
        } catch (Exception e){
            resultInfo.setCode(500);
            resultInfo.setMsg("用户添加失败");
        }*/

        return resultInfo;
    }


    /**
     * 添加用户
     * @param user
     * @return
     */
    @PostMapping("user02")
    @ApiOperation(value = "添加用户")
    @ApiImplicitParam(name = "user", value = "用户实体类")
    public ResultInfo addUser02(@Valid User user){
        ResultInfo resultInfo = new ResultInfo();

        //调用service层的添加方法
        userService.addUser(user);

        return resultInfo;
    }

    /**
     * 修改用户
     * @param user
     * @return
     */
    @PutMapping("user")
    @ApiOperation(value = "修改用户")
    @ApiImplicitParam(name = "user",value = "用户实体类")
    public ResultInfo updateUser(@RequestBody User user){
        ResultInfo resultInfo = new ResultInfo();

        //调用service层的添加方法
        userService.updateUser(user);
        /*try{
            //调用service层的添加方法
            userService.updateUser(user);
        }catch (ParamsException p){
            resultInfo.setCode(p.getCode());
            resultInfo.setMsg(p.getMsg());
        } catch (Exception e){
            resultInfo.setCode(500);
            resultInfo.setMsg("用户修改失败");
            e.printStackTrace();
        }*/

        return resultInfo;
    }

    /**
     * 删除用户
     * @param userId
     * @return
     */
    @DeleteMapping("user/{userId}")
    @ApiOperation(value = "删除用户")
    @ApiImplicitParam(name = "userId",value = "用户ID",required = true,paramType = "path")
    public ResultInfo deleteUser(@PathVariable Integer userId){
        ResultInfo resultInfo = new ResultInfo();

        //调用service层的添加方法
        userService.deleteUser(userId);

        /*try{
            //调用service层的添加方法
            userService.deleteUser(userId);
        }catch (ParamsException p){
            resultInfo.setCode(p.getCode());
            resultInfo.setMsg(p.getMsg());
        } catch (Exception e){
            resultInfo.setCode(500);
            resultInfo.setMsg("用户删除失败");
        }*/

        return resultInfo;
    }

    /**
     * 分页条件查询用户列表
     * @param userQuery
     * @return
     */
    @GetMapping("user/list")
    @ApiOperation(value = "分页条件查询用户列表")
    @ApiImplicitParam(name = "userQuery",value = "用户查询类")
    public PageInfo<User> selectByParams(UserQuery userQuery){
        return userService.selectByParams(userQuery);
    }

@ApiModel(value = "用户实体类")
public class User implements Serializable {
    @ApiModelProperty(name="id",value = "用户id",example = "0")
    private Integer id;//用户id
    @ApiModelProperty(value = "用户名称")
    private String userName;//用户名
    @ApiModelProperty(value = "用户密码")
    private String userPwd;//用户密码

	/*
		省略get|set
	*/

}

spring:
  ## 热部署配置
  devtools:
    restart:
      enabled: true
      # 设置重启的目录，添加目录的文件需要restart
      additional-paths: src/main/java
      # 解决项目自动重新编译后接口报404的问题
      poll-interval: 3000
      quiet-period: 1000

    <!--单元测试-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
    </dependency>

@RunWith(SpringRunner.class)
@SpringBootTest(classes={Starter.class})
public class TestUserService {

    //使用日志
    private Logger logger= LoggerFactory.getLogger(TestUserService.class);

    //注入service
    @Autowired
    private UserService userService;


    @Before
    public void before(){
        System.out.println("单元测试方法执行前执行...");
    }


    @Test
    public void test01(){
        logger.info("当前查询用户对象的用户名:{}",userService.queryUserById(10).getUserName());
    }

    @After
    public void after(){
        System.out.println("单元测试方法执行后执行...");
    }
}

@RunWith(SpringRunner.class)
@SpringBootTest(classes={Starter.class})
@AutoConfigureMockMvc
public class TestController {

    private Logger log = LoggerFactory.getLogger(TestController.class);
    @Autowired
    private MockMvc mockMvc;

    @Test
    public void test01() throws Exception {
        //构建请求
        MockHttpServletRequestBuilder request = MockMvcRequestBuilders.get("/user/list")
                .contentType("text/html;charset=UTF-8")//设置请求头
                .accept(MediaType.APPLICATION_JSON);//设置接收类型

        //发送请求，获取请求的结果
        ResultActions perform = mockMvc.perform(request);

        //校验请求结果
        perform.andExpect(MockMvcResultMatchers.status().isOk());

        //得到请求返回的结果
        MvcResult mvcResult = perform.andReturn();

        //获取请求返回的数据
        String data = mvcResult.getResponse().getContentAsString();

        System.out.println(data);

    }
}

@CacheConfig(cacheNames = "users")
public class UserService {。。。}

@Cacheable(value = "user", key = "#id")
User selectUserById(final Integer id);

@CachePut(value = "user", key = "#user.id")
public User save(User user) {
    users.add(user);
    return user;
}

@CacheEvict(value = "user", key = "#id")
void delete(final Integer id);

@Caching(
    put = {
    @CachePut(value = "user", key = "#user.id"),
    @CachePut(value = "user", key = "#user.username"),
    @CachePut(value = "user", key = "#user.age")
    }
}

 <!-- Ehcache -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>
    <!-- Ehcache 坐标 -->
    <dependency>
      <groupId>net.sf.ehcache</groupId>
      <artifactId>ehcache</artifactId>
    </dependency>

<ehcache name="mycache">
    <diskStore path="E:\Informations\MSB\project\springboot\cache"/>
    <!--
    name:缓存名称。
    maxElementsInMemory:缓存最大数目
    maxElementsOnDisk：硬盘最大缓存个数。
    eternal:对象是否永久有效，一但设置了，timeout将不起作用。
    overflowToDisk:是否保存到磁盘，当系统宕机时
    timeToIdleSeconds:设置对象在失效前的允许闲置时间（单位：秒）。
        仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
    timeToLiveSeconds:设置对象在失效前允许存活时间（单位：秒）。
        最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0，也就是对象存活时间无穷大。
    diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists
    between restarts of the Virtual Machine. The default value is false.
    diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
    diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
    memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。
    默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。
    clearOnFlush：内存数量最大时是否清除。
    memoryStoreEvictionPolicy:可选策略有：LRU（最近最少使用，默认策略）、FIFO（先进先出）、LFU（最少访问次数）。
    FIFO，first in first out，这个是大家最熟的，先进先出。
    LFU， Less Frequently Used，最近最少被访问的。
    LRU，Least Recently Used，最近最少使用的，缓存的元素有一个时间戳，
    当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。
    -->
    <defaultCache
            maxElementsInMemory="10000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            maxElementsOnDisk="10000000"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU">
    </defaultCache>
    <cache
            name="users"
            eternal="false"
            maxElementsInMemory="100"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="0"
            timeToLiveSeconds="300"
            memoryStoreEvictionPolicy="LRU"/>
</ehcache>

spring:
  # Ehcache缓存配置
  cache:
    ehcache:
      config: classpath:ehcache.xml

@SpringBootApplication
@EnableCaching//启动缓存
@MapperScan("com.msb.springboot.dao")
public class Starter {
    public static void main(String[] args) {
        SpringApplication.run(Starter.class);
    }
}

@ApiModel(value = "用户实体类")
public class User implements Serializable {
    @ApiModelProperty(name="id",value = "用户id",example = "0")
    private Integer id;//用户id
    @ApiModelProperty(value = "用户名称")
    @NotNull(message = "用户名称不能为空")
    private String userName;//用户名
    @ApiModelProperty(value = "用户密码")
    @NotNull(message = "用户密码不能为空")
    private String userPwd;//用户密码

    /*
    	省略 get|set方法
    */

}

    @Cacheable(value = "users",key = "#id")
    public User queryUserById(Integer id){
        return userMapper.queryUserById(id);
    }

    @Cacheable(value = "users",key = "#userQuery.userName+'-'+#userQuery.pageNum+'-'+#userQuery.pageSize")
    public PageInfo<User> selectByParams(UserQuery userQuery){
        //开启分页
        PageHelper.startPage(userQuery.getPageNum(),userQuery.getPageSize());
        //返回分页结果
        return new PageInfo<User>(userMapper.selectByParams(userQuery));
    }

 	@CachePut(value = "users",key = "#user.id")
    public User updateUser(User user){
        //用户名 非空判断
        AssertUtil.isTrue(StringUtils.isBlank(user.getUserName()),"用户名称不能为空");
        //用户密码 非空判断
        AssertUtil.isTrue(StringUtils.isBlank(user.getUserPwd()),"用户密码不能为空");
        //通过用户名查询用户对象
        User temp = userMapper.queryUserByName(user.getUserName());
        //如果用户对象不为空且用户id不一致
        AssertUtil.isTrue(null!=temp && !(user.getId().equals(temp.getId())),"用户名已存在，请重新输入");
        //执行修改操作，判断受影响的行数
        AssertUtil.isTrue(userMapper.updateUser(user)!=1,"用户添加失败");

        return user;
    }

 	@Transactional(propagation = Propagation.REQUIRED)
    @CacheEvict(value = "users",key = "#id")
    public void deleteUser(Integer id){
        //判断id是否为空且用户对象存在
        AssertUtil.isTrue(null==id &&userMapper.queryUserById(id)==null,"待删除记录不存在");
        //执行删除操作，判断受影响的行数
        AssertUtil.isTrue(userMapper.deleteUser(id)!=1,"用户删除失败");
    }

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

public class MyFirstJob implements Job {
    private Logger log = LoggerFactory.getLogger(MyFirstJob.class);
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        TriggerKey triggerKey = context.getTrigger().getKey();
        log.info("触发器:"+triggerKey.getName()+"-->所属组:"+triggerKey.getGroup()+"-->"+sdf.format(new Date())+"-->"+"hello Spring Boot Quartz...");
    }
}

@Configuration
public class QuartzConfig {
    @Bean
    public JobDetail jobDetail1(){
    	return JobBuilder.newJob(MyFirstJob.class).storeDurably().build();
    }
    
    @Bean
    public Trigger trigger1(){
    	SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule()
        //每一秒执行一次
        .withIntervalInSeconds(1)
        //永久重复，一直执行下去
        .repeatForever();
        return TriggerBuilder.newTrigger()
        .withIdentity("trigger1","group1")
        .withSchedule(scheduleBuilder)
		.forJob(jobDetail1())
		.build();
}
        // 每两秒触发一次任务
        @Bean
        public Trigger trigger2(){
        return TriggerBuilder.newTrigger()
        .withIdentity("trigger2", "group1")
        .withSchedule(CronScheduleBuilder.cronSchedule("0/5 * * * * ? *"))
        .forJob(jobDetail1())
        .build();
        }
}    

@ControllerAdvice//声明该类作为全局异常处理的切面类
public class GlobalExceptionHandler {

    /**
     * 全局异常处理 返回json
     * @param e
     * @return
     */
    @ExceptionHandler(value = Exception.class)
    @ResponseBody
    public ResultInfo exceptionHandler(Exception e){
        ResultInfo resultInfo=new ResultInfo();
        resultInfo.setCode(500);
        resultInfo.setMsg("访问异常!");
        return resultInfo;
    }

    /**
     * 处理特定异常
     * @param p
     * @return
     */
    @ExceptionHandler(value = ParamsException.class)
    @ResponseBody
    public ResultInfo ParamsExceptionHandler(ParamsException p){
        ResultInfo resultInfo=new ResultInfo();
        resultInfo.setCode(p.getCode());
        resultInfo.setMsg(p.getMsg());
        return resultInfo;
    }

}