1
2
3
4
5
6
7
8

// tomcat目录结构
--bin           // 可执行文件目录，录下有两类文件，一种是以.bat 结尾的，是Windows系统的可执行文件，一种是以.sh结尾的，是Linux系统的可执行文件
--conf          // 配置文件
--lib           // Tomcat依赖的jar包
--logs          // 日志文件
--temp          // 临时文件
--webapps       // 应用发布目录（以后项目部署的目录）
--work          // 工作目录

1
2

// 修改控制台编码
java.util.logging.ConsoleHandler.encoding=GBK

1

<Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirecotPort="8443">

1
2
3
4
5
6

<dependency>
	<groupId>javax.servlet</groupId>
	<artifactId>javax.servlet-api</artifactId>
	<version>4.0.1</version>
	<scope>provided</scope>
</dependency>

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

@WebServlet(urlPatterns="/hello")
public class HelloServlet expends HttpServlet{
  @Override
  protected void doGet(HttpServletRequest request,HttpServletResponse response) throws ServletException,IOException{
  	//接收请求参数
		String name = request.getParameter("name");
		//响应结果
		String respMsg = "<h1>Hello, " + name + " ~</h1>";
		response.getWriter().write(respMsg);
  }
  
  @Override
	protected void doPost(HttpServletRequest request,HttpServletResponse response) throws ServletException,IOException {
		doGet(request, response);
	}
}

1
2

@GetMapping("/depts")
public void list(){}

1
2

@Component
public class DeptServiceImpl implements DeptService{}

1
2
3

@Primary
@Service
public class DeptServiceImpl implements DeptService {}

1
2
3

@Qualifier("deptServiceImpl")
@Autowired
private DeptService deptService;

1
2

@Resource(name = "deptServiceImpl")
private DeptService deptService;

1
2

@Autowired
private DeptDao deptDao;

1
2
3
4
5

@DeleteMapping("/depts")
public Result delete(HttpServletRequest request){
  String idStr = request.getParameter("id");
  int id = Integer.parseInt(idStr);
}

1
2
3
4
5

@DeleteMapping("/depts")
public Result delete(@RequestParam("id") Integer id){}

@DeleteMapping("/depts")
public Result delete(@RequestParam List<Integer> ids){}

1
2
3
4
5

@DeleteMapping("/depts")
public Result delete(Integer id){}

@DeleteMapping("/depts")
public Result delete(Integer[] ids){}

1
2
3
4
5
6
7
8

#数据库连接的url
spring.datasource.url=jdbc:mysql://localhost:3306/web01
#驱动类名称
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
#连接数据库的用户名
spring.datasource.username=root
#连接数据库的密码
spring.datasource.password=root@1234

1
2
3
4

# 在控制台输出sql语句的执行日志
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
# mapper映射开启驼峰命名，create_time会被映射成createTime
mybatis.configuration.map-underscore-to-camel-case=true

1
2

#spring事务管理日志
logging.level.org.springframework.jdbc.support.JdbcTransactionManager = debug

1
2
3
4

#配置单个文件最大上传大小
spring.servlet.multipart.max-file-size=10MB
#配置单个请求最大上传大小(一次请求可以上传多个文件)
spring.servlet.multipart.max-request-size=100MB

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

@PostMapping("/upload")
public Result upload(MultipartFile file) throws IOException {
  // file.getInputStream(); 获取接收到的文件内容的输入流
  //获取原始文件名
  String originalFilename = file.getOriginalFilename();
  //构建新的文件名
  String newFileName = UUID.randomUUID().toString()+originalFilename.substring(originalFilename.lastIndexOf("."));
  //将文件保存在服务器端 D:/images/ 目录下
  file.transferTo(new File("D:/images/"+newFileName));
  return Result.success();
}

1
2
3
4
5

<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<version>8.0.33</version>
</dependency>

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

@Test
public void testUpdate() throws Exception {
  //1.准备工作
  //1.1 注册驱动
  Class.forName("com.mysql.cj.jdbc.Driver");
  //1.2 获取连接
  String url = "jdbc:mysql://localhost:3306/web";
  Connection connection = DriverManager.getConnection(url,"root", "1234");
  //1.3 获取SQL语句执行对象
  Statement statement = connection.createStatement();
  //2.执行SQL
  statement.executeUpdate("update user set password ='1234567890' where id = 1");
  //3.释放资源
  statement.close();
  connection.close();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

ResultSet resultSet = statement.executeQuery("select * from user where username = 'lvbu' and password = '123456'");
// 获取结果
while (resultSet.next()){// 将光标从当前位置向前移动一行，并判断当前行是否为有效行，返回值为 boolean
  int id = resultSet.getInt("id");
  String username = resultSet.getString("username");
  String password = resultSet.getString("password");
  String name = resultSet.getString("name");
  int age = resultSet.getInt("age");
  System.out.println(new
  User(id,username,password,name,age));
}

1
2
3
4
5
6

// 获取数据库执行对象 Statement
PreparedStatement preparedStatement = connection.prepareStatement("select * from user where username =? and password = ?");
preparedStatement.setString(1, _username);
preparedStatement.setString(2, _password);
// 执行sql
ResultSet resultSet = preparedStatement.executeQuery();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

<!-- Mybatis的起步依赖 -->
<dependency>
  <groupId>org.mybatis.spring.boot</groupId>
  <artifactId>mybatis-spring-boot-starter</artifactId>
  <version>3.0.3</version>
</dependency>
<!-- MySQL驱动 -->
<dependency>
  <groupId>com.mysql</groupId>
  <artifactId>mysql-connector-j</artifactId>
  <scope>runtime</scope>
</dependency>

1
2
3

// com.itheima.mapper包下的EmpMapper接口文件
@Select("select * from user")
public List<User> findAll();

1
2
3
4

@Results({@Result(column = "create_time", property ="createTime"),
@Result(column = "update_time", property = "updateTime")})
@Select("select id, name, create_time, update_time from dept")
public List<Dept> findAll();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.mapper.EmpMapper">
  <!--查询操作-->
  <select id="findAll" resultType="com.itheima.pojo.User">
  select * from user
  </select>
</mapper>

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

<mapper namespace="com.itheima.mapper.DeptMapper">
	<!--动态更新部门数据-->
	<update id="update">
		update dept
		<set>
      <if test="name != null and name != ''">
      name = #{name},
      </if>
      <if test="updateTime != null">
      update_time = #{updateTime}
      </if>
		</set>
  	where id = #{id}
  </update>
</mapper>

1
2
3
4
5
6
7
8
9

<mapper namespace="com.itheima.mapper.EmpExprMapper">
	<!--批量插入员工工作经历信息-->
  <insert id="insertBatch">
    insert into emp_expr (emp_id, begin, end, company, job) values
    <foreach collection="exprList" item="expr" separator=",">
      (#{expr.empId}, #{expr.begin}, #{expr.end}, #{expr.company}, #{expr.job})
    </foreach>
  </insert>
</mapper>

1
2
3
4
5
6
7
8
9

select e.*,
  ee.id ee_id,
  ee.emp_id ee_empid,
  ee.begin ee_begin,
  ee.end ee_end,
  ee.company ee_company,
  ee.job ee_job
from emp e left join emp_expr ee on e.id = ee.emp_id
where e.id = #{id}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

<!--自定义结果集ResultMap-->
<resultMap id="empResultMap" type="com.itheima.pojo.Emp">
  <id column="id" property="id" />
  <result column="username" property="username" />
  <result column="password" property="password" />
  <result column="name" property="name" />
  <result column="gender" property="gender" />
  <result column="phone" property="phone" />
  <result column="job" property="job" />
  <result column="salary" property="salary" />
  <result column="image" property="image" />
  <result column="entry_date" property="entryDate" />
  <result column="dept_id" property="deptId" />
  <result column="create_time" property="createTime" />
  <result column="update_time" property="updateTime" />
  <!--封装exprList-->
  <collection property="exprList" ofType="com.itheima.pojo.EmpExpr">
    <id column="ee_id" property="id"/>
    <result column="ee_company" property="company"/>
    <result column="ee_job" property="job"/>
    <result column="ee_begin" property="begin"/>
    <result column="ee_end" property="end"/>
    <result column="ee_empid" property="empId"/>
  </collection>
</resultMap>
<!--根据ID查询员工的详细信息-->
<select id="getById" resultMap="empResultMap">
  select e.*,
    ee.id ee_id,
    ee.emp_id ee_empid,
    ee.begin ee_begin,
    ee.end ee_end,
    ee.company ee_company,
    ee.job ee_job
  from emp e left join emp_expr ee on e.id = ee.emp_id
  where e.id = #{id}
</select>

1
2
3
4
5
6

<dependency>
  <!-- Druid连接池依赖 -->
  <groupId>com.alibaba</groupId>
  <artifactId>druid-spring-boot-starter</artifactId>
  <version>1.2.19</version>
</dependency>

1
2
3
4
5

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.druid.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.druid.url=jdbc:mysql://localhost:3306/mybatis
spring.datasource.druid.username=root
spring.datasource.druid.password=1234

1
2
3
4
5

@DeleteMapping("/depts")
public Result delete(@RequestParam("id") Integer id){}

@DeleteMapping("/depts")
public Result delete(@RequestParam List<Integer> ids){}

1
2
3
4

@PostMapping
public Result add(@RequestBody Dept dept){
	System.out.println("添加部门: " + dept);
}

1
2

@GetMapping("/{id}")
public Result getInfo(@PathVariable Integer id){}

1
2

public void countSaleData(@DateTimeFormat(pattern="yyyy-MM-dd") LocalDate begin,
													@DateTimeFormat(pattern="yyyy-MM-dd") LocalDate end){}

1
2

@Value("${aliyun.oss.endpint}")
private String endpoint;

1
2
3
4
5
6
7

@Data
@Component
@ConfigurationProperties(prefix = "aliyun.oss")
public class AliyunOSSProperties {
	private String endpoint;
	private String bucketName;
}

1
2

@RestControllerAdvice
public class GlobalExceptionHandler {}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

@MapperScan("com.sky.mapper")
@SpringBootApplication
@EnableTransactionManagement //开启注解方式的事务管理
@Slf4j
@EnableCaching
@EnableScheduling
public class SkyApplication {
    public static void main(String[] args) {
        SpringApplication.run(SkyApplication.class, args);
        log.info("server started");
    }
}

1
2

@Select("select * from user")
public List<User> findAll();

1
2
3
4

@Mapper
public interface UserMapper {
  // 其他查询接口
}

1
2
3

@Options(useGeneratedKeys = true, keyProperty = "id")
@Insert("insert into emp(username, name, gender, phone, job,salary, image, entry_date, dept_id, create_time, update_time) " +"values (#{username},#{name},#{gender},#{phone},#{job},#{salary},#{image},#{entryDate},#{deptId},#{createTime},#{updateTime})")
void insert(Emp emp);

1
2
3
4

@EnableCaching
public class SkyApplication {
  
}

1
2
3
4
5
6
7
8

@Cacheable(cacheNames="user",key="#id") // 最终生成的key为：user::id的值
@GetMapping
public void getById(Long id) {}


@Cacheable(cacheNames="user",key="root.args[1]") // 最终生成的key为：user::name的值
@GetMapping
public void getById(Long id,String name) {}

1
2
3
4
5
6

@CachePut(cahceNames="user", key="#result.id")
@PostMapping
public User save(@ResponseBody User user){
  userMpaaer.insert(user);
  return user;
}

1
2

@CacheEvict(CacheName="user",key="#id") // 删除指定id的缓存
@CacheEvict(CacheName="user",allEntries=true) // allEntries属性，默认值是false，设置为true代表删除全部

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

@RestControllerAdvice
public class GlobalExceptionHandler {
  //处理异常
  @ExceptionHandler
  public Result ex(Exception e){//方法形参中指定能够处理的异常类型
  	e.printStackTrace();//打印堆栈中的异常信息
  	//捕获到异常之后，响应一个标准的Result
  	return Result.error("对不起,操作失败,请联系管理员");
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

/**
 * 令牌校验过滤器
 */
@Slf4j
@WebFilter(urlPatterns = "/*")
public class TokenFilter implements Filter {

    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        //1. 获取请求url。
        String url = request.getRequestURL().toString();

        //2. 判断请求url中是否包含login，如果包含，说明是登录操作，放行。
        if(url.contains("login")){ //登录请求
            log.info("登录请求 , 直接放行");
            chain.doFilter(request, response);
            return;
        }

        //3. 获取请求头中的令牌（token）。
        String jwt = request.getHeader("token");

        //4. 判断令牌是否存在，如果不存在，返回错误结果（未登录）。
        if(!StringUtils.hasLength(jwt)){ //jwt为空
            log.info("获取到jwt令牌为空, 返回错误结果");
            response.setStatus(HttpStatus.SC_UNAUTHORIZED);
            return;
        }

        //5. 解析token，如果解析失败，返回错误结果（未登录）。
        try {
            JwtUtils.parseJWT(jwt);
        } catch (Exception e) {
            e.printStackTrace();
            log.info("解析令牌失败, 返回错误结果");
            response.setStatus(HttpStatus.SC_UNAUTHORIZED);
            return;
        }

        //6. 放行。
        log.info("令牌合法, 放行");
        chain.doFilter(request , response);
    }
}

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

@Component
public class DemoInterceptor implements HandlerInterceptor {
  //目标资源方法执行前执行。 返回true：放行 返回false：不放行
  public boolean preHandle(HttpServletRequest request,HttpServletResponse response, Object handler) throws Exception {
    return true; //true表示放行
  }
  // 目标资源方法执行后执行
  @Override
  public void postHandle(HttpServletRequest request,HttpServletResponse response, Object handler,ModelAndView modelAndView) throws Exception {
  	System.out.println("postHandle ... ");
  }
  //视图渲染完毕后执行，最后执行
  @Override
  public void afterCompletion(HttpServletRequest request,HttpServletResponse response, Object handler, Exception ex) throws Exception {
  	System.out.println("afterCompletion .... ");
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public class WebConfig implements WebMvcConfigurer {
  //自定义的拦截器对象
  @Autowired
  private DemoInterceptor demoInterceptor;
  
  @Override
  public void addInterceptors(InterceptorRegistry registry) {
    //注册自定义拦截器对象
    registry.addInterceptor(demoInterceptor).addPathPatterns("/**").excludePathPatterns("/login");
  }
}

1
2
3
4

import org.springframework.util.DigestUtils;


pwd = DigestUtils.md5DigestAsHex(pwd.getBytes()); // 获得md5加密后的字符串

1
2
3
4
5

<dependency>
  <groupId>com.github.xiaoymin</groupId>
  <artifactId>knife4j-spring-boot-starter</artifactId>
  <version>3.0.2</version>
</dependency>

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

@Bean
public Docket docket() {
  ApiInfo apiInfo = new ApiInfoBuilder()
    .title("苍穹外卖项目接口文档")
    .version("2.0")
    .description("苍穹外卖项目接口文档")
    .build();
  Docket docket = new Docket(DocumentationType.SWAGGER_2)
    .apiInfo(apiInfo)
    .select()
    // 扫描的控制器所在的包
    .apis(RequestHandlerSelectors.basePackage("com.sky.controller"))
    .paths(PathSelectors.any())
    .build();
  return docket;
}

1
2
3
4

protected void addResourceHandlers(ResourceHandlerRegistry registry) {
  registry.addResourceHandler("/doc.html").addResourceLocations("classpath:/META-INF/resources/");
  registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
}

1
2

@Api(tags="员工相关接口")
public class EmployeeController{}

1
2
3
4
5

@Api(tags="员工相关接口")
public class EmployeeController{
  @ApiOperation("员工登录")
  @PostMapping("/login")
}

1
2

@ApiModel(description="员工登录时传递的数据模型")
public class EmployeeLogin{}

1
2
3
4
5

@ApiModel(description="员工登录时传递的数据模型")
public class EmployeeLogin{
  @ApiModelProperty("用户名")
  private String username;
}

1

threadLocal.set(id);

1

threadLocal.get();

1
2
3
4

<dependency>
	<group>com.github.pagehelper</group>
  <artifactId>pagehelper-spring-boot-starter</artifactId>
</dependency>

1
2
3
4
5
6
7
8

@Data
@AllArgsConstructor
@NoArgsConstructor
public class PageResult implements Serializable {
    private long total; //总记录数

    private List records; //当前页数据集合
}

1
2
3
4
5
6

// 1、设置分页参数
PageHelper.startPage(dto.getPage(),dto.getPageSize());
// 2、调用mapper的查询方法，并强转返回类型为page
Page<Employee> page = employeeMapper.list(dto.getName());
// 3、封装pageResult对象并返回
return new PageResult(page.getTotal(),page.getResult());

1
2

@JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
private LocatDateTime updateTime;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

package com.sky.json;

import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

import static com.fasterxml.jackson.databind.DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES;

/**
 * 对象映射器:基于jackson将Java对象转为json，或者将json转为Java对象
 * 将JSON解析为Java对象的过程称为 [从JSON反序列化Java对象]
 * 从Java对象生成JSON的过程称为 [序列化Java对象到JSON]
 */
public class JacksonObjectMapper extends ObjectMapper {

    public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
    //public static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
    public static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm";
    public static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";

    public JacksonObjectMapper() {
        super();
        //收到未知属性时不报异常
        this.configure(FAIL_ON_UNKNOWN_PROPERTIES, false);

        //反序列化时，属性不存在的兼容处理
        this.getDeserializationConfig().withoutFeatures(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);

        SimpleModule simpleModule = new SimpleModule()
                .addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)))
                .addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)))
                .addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)))
                .addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)))
                .addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)))
                .addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));

        //注册功能模块 例如，可以添加自定义序列化器和反序列化器
        this.registerModule(simpleModule);
    }
}

1
2
3
4
5
6
7
8
9

protected void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
  log.info("扩展消息转换器...");
  //创建消息转换器对象
  MappingJackson2HttpMessageConverter messageConverter = new MappingJackson2HttpMessageConverter();
  //设置对象转换器，底层使用Jackson将Java对象转为json字符串
  messageConverter.setObjectMapper(new JacksonObjectMapper());
  //将我们自己的消息转换器对象追加到Spring mvc框架的容器中去
  converters.add(0, messageConverter);// 0最高优先级
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

@Override
public void saveEmp(EmployeeDTO employeedto) {
  Employee employee = new Employee();
  // 属性拷贝
  BeanUtils.copyProperties(employeedto, employee); // 第三个参数为忽略的字段，忽略的字段不参与属性拷贝
  employee.setStatus(StatusConstant.ENABLE);
  employee.setPassword(DigestUtils.md5DigestAsHex(PasswordConstant.DEFAULT_PASSWORD.getBytes()));

  Long empId = BaseContext.getCurrentId();

  employeeMapper.saveEmp(employee);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import com.sky.enumeration.OperationType;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AutoFill {
    OperationType value();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

package com.sky.aop;

import com.sky.annotation.AutoFill;
import com.sky.constant.AutoFillConstant;
import com.sky.context.BaseContext;
import com.sky.enumeration.OperationType;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;


@Aspect
@Component
@Slf4j
public class AutoFillAspect {

    @Pointcut("execution(* com.sky.mapper.*.*(..)) && @annotation(com.sky.annotation.AutoFill)")
    public void autoFillPointcut() {
    }

    @Before("autoFillPointcut()")
    public void autoFill(JoinPoint joinPoint) {
        log.info("开始进行公共字段自动填充");
        // 1、获取目标方法上的注解，并拿到注解里的属性值
        // 1.1 获取方法前面
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        // 1.2 获取方法对象
        AutoFill autoFill = methodSignature.getMethod().getAnnotation(AutoFill.class);
        // 1.3 获取注解的value值：insert/update
        OperationType operationType = autoFill.value();

        log.info("当前操作类型：{}", operationType);

        // 2、获取目标方法的参数对象
        Object[] args = joinPoint.getArgs();
        if (args == null || args.length == 0) return;
        // 2.1 获取对应的实体对象
        Object entity = args[0];

        // 3、判断注解中属性值，如果是insert，就补充四个字段（创建日期、创建人、更新日期、更新人）
        switch (operationType) {
            case INSERT:
                log.info("开始进行插入操作，公共字段填充");
                try {
                    // setCreateTime
                    entity.getClass().getMethod(AutoFillConstant.SET_CREATE_TIME, LocalDateTime.class).invoke(entity, LocalDateTime.now());
                    // setCreateUser
                    entity.getClass().getMethod(AutoFillConstant.SET_CREATE_USER, Long.class).invoke(entity, BaseContext.getCurrentId());
                    // setUpdateTime
                    entity.getClass().getMethod(AutoFillConstant.SET_UPDATE_TIME, LocalDateTime.class).invoke(entity, LocalDateTime.now());
                    // setUpdateUser
                    entity.getClass().getMethod(AutoFillConstant.SET_UPDATE_USER, Long.class).invoke(entity, BaseContext.getCurrentId());
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
                break;
            case UPDATE:
                log.info("开始进行更新操作，公共字段填充");
                try {
                    // setUpdateTime
                    entity.getClass().getMethod(AutoFillConstant.SET_UPDATE_TIME, LocalDateTime.class).invoke(entity, LocalDateTime.now());
                    // setUpdateUser
                    entity.getClass().getMethod(AutoFillConstant.SET_UPDATE_USER, Long.class).invoke(entity, BaseContext.getCurrentId());
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
                break;
            default:
                break;
        }
    }
}

1
2

@AutoFill(value = OperationType.INSERT)
void insert(Category category);

1
2
3
4

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

1
2
3
4
5

spring:
	redis:
		host: localhost
		port: 6379
		password: 123456

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
@Slf4j
public class RedisConfiguration {

    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        log.info("开始创建redis模板对象...");
        RedisTemplate redisTemplate = new RedisTemplate();
        //设置redis key的序列化器， 默认是： JdkSerializationRedisSerializer
        redisTemplate.setKeySerializer(new StringRedisSerializer());
      	// 不推荐设置redis value的序列化器
        //  redisTemplate.setValueSerializer(new StringRedisSerializer());
        //设置redis的连接工厂对象
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        return redisTemplate;
    }
}

1
2
3
4

// redisTemplate.opsForValue()获取redis的string对象
redisTemplate.opsForValue().get("name"); 
redisTemplate.opsForValue().set("name","snailsir");
redisTemplate.delete("name");

1
2
3
4

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

1
2
3
4
5

<dependency>
  <groupId>org.apache.httpcomponents</groupId>
  <artifactId>httpclient</artifactId>
  <scope>4.5.13</scope>
</dependency>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

@Test
public void testGet() throws Exception {
  // 1、创建HttpClient对象
  CloseableHttpClient httpClient = HttpClients.createDefault();

  // 2、创建HttpGet请求对象--构造出请求路径、请求参数
  HttpGet httpGet = new HttpGet("http://localhost:8080/user/shop/status");

  // 3、调用HttpClient对象的execute方法，发送请求
  CloseableHttpResponse response = httpClient.execute(httpGet);

  // 4、解析响应数据
  int statusCode = response.getStatusLine().getStatusCode();
  System.out.println("statusCode = " + statusCode);
  HttpEntity entity = response.getEntity();
  if (entity != null) {
    String string = EntityUtils.toString(entity);
    System.out.println("entity = " + string);
  }
  // 5、释放资源
  response.close();
  httpClient.close();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

 @Test
public void testPost() throws Exception {
  // 1、创建HttpClient对象
  CloseableHttpClient httpClient = HttpClients.createDefault();

  // 2、创建HttpPost请求对象--构造出请求路径、请求参数
  HttpPost httpPost = new HttpPost("http://localhost:8080/user/shop/status");

  // 2.1 构造请求体参数
  Map map = new HashMap();
  map.put("username", "admin");
  map.put("password", "123456");
  // 构造请求体
  StringEntity stringEntity = new StringEntity(map.toString());
  // 设置请求编码
  stringEntity.setContentEncoding("UTF-8");
  // 设置数据类型
  stringEntity.setContentType("application/json");
  // 设置请求体
  httpPost.setEntity(stringEntity);

  // 3、调用HttpClient对象的execute方法，发送请求
  CloseableHttpResponse response = httpClient.execute(httpPost);

  // 4、解析响应数据
  int statusCode = response.getStatusLine().getStatusCode();
  System.out.println("statusCode = " + statusCode);
  HttpEntity entity = response.getEntity();
  if (entity != null) {
    String string = EntityUtils.toString(entity);
    System.out.println("entity = " + string);
  }
  // 5、释放资源
  response.close();
  httpClient.close();
}