SSM复习 ?

1
2
3
4
5
6
//组件注册
@Bean("zhangsan")
public Person zhangsan(){
    var person = Person.builder().age(10).sex(1).name("我是傻逼").build();
    return person;
}

1
2
3
4
5
6
7
8
@Bean
public NBClass nbclass(){
    return new NBClass;
}


//方法二直接导入
@Import(NBClass.Class)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Component
public class BYDFactory implements FactoryBean<Car> {

    @Override
    public Car getObject() throws Exception {
        return new Car();
    }

    @Override
    public Class<Car> getObjectType() {
        return Car.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }
}

1
2
3
4
5
6
@ConditionalOnResource(resources = "")
@Conditional(CarContional.class)
@Bean
public Car car1(){
    return new Car();
}

1
2
3
4
5
@Autowired
List<Person> persons;

@Autowired
Map<String,Person> personMap;

1
2
3
4
5
6
7
public calss UserDao{
    Dog haha;
    //spring会自动在容器里面找东西吃，然后扔给UserDao
    public UserDao(Dog dog){
        this.haha = dog;
    }
}

1
2
3
public void setDog(@Qualifer("dog1") Dog dog){
    this.dog = dog ;
}

1
2
3
4
5
6
7
8
@Value("字面值")

@Value("${dog.name:哈哈}") //默认从动态文件application.properties中取出来,可以用冒号赋值默认值
@PropertySource("classpath:cat.properties")  //注意这个注解是加载的意思，而不是仅用这个文件的意思，
// 是在原有文件之上再加载，所以理论上直接放在最外层或者Config层都行

@Value("#{SpEL}")  //表达式
@Value("#{T(java.util.UUID).randomUUID().toString()}")

1
2
3
4
5
6
7
8
9
@Profile("dev")
@Profile("test")
@Profile("prod")
@Profile("default")  //必须得有一个default

@Profile({"dev",defalut})

//在application.properties中
spring.profiles.active = prod //即可切换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class DynamicProxy {

    public static Object getDynamicProxy(Object obj){
        var proxyInstance = Proxy.newProxyInstance(
          obj.getClass().getClassLoader(),
          obj.getClass().getInterfaces(),
                (proxy,method,args) -> {
                    System.out.println("在你执行之前：");
                    var result = method.invoke(obj,args);
                    System.out.println("在你执行之后");
                    return result;
                }
        );

        return proxyInstance;
    }
}

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
package com.hzyxsj.javassmaop.aspect;

import org.aspectj.lang.annotation.*;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

/**
 * 作者：宇宙超级无敌大马猴
 * 姓：亥
 * 字：子曜
 * 号：栖逸居士
 * 版本号：随缘
 */

@Component
@Aspect
public class LogAspect {
    @Before("execution(int add(int,int))")
    public void logBefore(JoinPoint joinpoint){
        System.out.println("this is the logBefore");
    }
    @AfterReturning(value ="execution(int add(int,int))"，returning = "result")
    public void logAfterReturning(JoinPoint joinpoint,Object result){
        System.out.println("this is the logAfterReturning");
    }

    @AfterThrowing(value = "execution(int add(int,int))",
    throwing = "e")
    public void logAfterThrowing(JoinPoint joinpoint,Exception e){
        System.out.println("this is the logAfterThrowing");
    }
    @After("execution(int add(int,int))")
    public void logAfter(JoinPoint joinpoint){
        System.out.println("this is the logAfter");
    }

}
//切入点表达式的写法
execution(方法的全签名)
[public] int [com..Class].MethodName(int,int) [throw] 
//要好好写切面表达式，不然就炸了
//其他写法
//within this  target都不重要，我都听着睡着了
//重点  args
@Before(execution(args(int,int)))
//这里定义切面的方式非常多
//老师讲的比较乱，所以以后可以补一补这里

1
2
3
4
5
6
7
8
9
10
11
@Pointcut("切入点表达式")
public class pointCut(){}

@Before(value="pointCut()")

//多切面如何运行
//相当于套娃，层层嵌套
  前置1 ->前置2->返回或异常2->后置2->返回或异常1->后置1
//对于类型名一般默认按照首字母排序
//但我们可以手动排序
@Order(1)  //数字越小，优先级越高，越是外层

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Aspect
@Component
public class LogAround {
    @Pointcut("execution(int add(int,int))")
    public void getCut(){
    }
    @Around("getCut()")
    public  Object aroundlog(ProceedingJoinPoint pjp) throws Throwable {
        Object[] args = pjp.getArgs();
        System.out.println("进行前置通知");
        Object result = null   ;
        try {
            result = pjp.proceed(args);
            System.out.println("this is the AfterReturning");
        } catch (Throwable e) {
            System.out.println("this is the AfterThrowing Around");
        } finally {
            System.out.println("this is the After Around");
        }
        return result;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Controller
@ResponseBody
//这俩可以合体，标在类上
@RestController

@RequestMapping("/hello")  //路径映射
@RequestMapping("/hello?") //任意一个字符
@RequestMapping("/hello*")  //任意多个字符  
@RequestMapping("/hello**")  //任意层级
//精确优先  
//属性限定
value = ""
// GET,HEAD,POST,PUT,PATCH,DELETE,OPTIONS,TRACE
method = {RequestMethod.POST,RequestMethod.GET}  

params = "username"  //必须给我一个username
params = "age=18"   //必须有给我age=18
params = {"!username"}

headers = {"haha"}

consumes = "application/json"  
consumes = "text/html" //必须携带数据

1
2
3
4
@RequestParam("Username") String name //默认必须携带
@requestParam(value = "Password", required = false) String password
@requestParam(value = "Password", defaultValue = "66666") String password

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
//请求头
@RequestHeader("host") String host

//cookie获取
@CookieValue("ck") String ck 

//POJO支持级联封装


//获取请求体数据json变为POJO
(@RequestBody Person person)

//文件上传
@RequestParam("headerImg") MultipartFile headerImgFile,
@RequestParam("lifeimg") MultipartFile[] lifeimgs

String originalname = headerImgFile.getOriginalFilename();
//还可以进行许多操作
headerImgFile.transferTo(new File(path));  //直接干啦

//SpringMCV默认有上传文件大小1MB
//自己改配置spring.servlet.multipart.max-file-size=1GB

(HttpEntity<Person> entity) //直接拿到整个请求
entity.getBody();   //泛型就是请求体的类型
entity.getHeaders();


//支持你的servelt

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
//返回json，MVC会自己转json
@ResponseBody  //已经封装到RestController里面了
return POJO;
return Map; 

//文件下载
@GetMapping("/download/stream")
public ResponseEntity<InputStreamResource> downloadStream() throws IOException {

    File file = new File("path");
    InputStreamResource resource =
            new InputStreamResource(new FileInputStream(file));

    String encodedFileName = URLEncoder.encode("中文.txt", StandardCharsets.UTF_8).replaceAll("\\+", "%20");

    return ResponseEntity.ok()
            .contentType(MediaType.APPLICATION_OCTET_STREAM)
            .contentLength(file.length())
            .header(HttpHeaders.CONTENT_DISPOSITION,
                    "attachment; filename*=UTF-8''" + encodedFileName)
            .body(resource);
}


//页面跳转
Thymeleaf 

这个直接跳过了，后面应该不可能了解这个了

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
@GetMapping(value = "/employee/{id}")
public String get(@PathVariable Long id)

//封装返回数据
@Data
public class R<T> {
    private int code;
    private String msg;
    private T data;

    private R(int code, String msg, T data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
    }

    public static <T> R<T> ok(T data) {
        return new R<>(ResultCode.SUCCESS.getCode(),
                       ResultCode.SUCCESS.getMsg(),
                       data);
    }

    public static <T> R<T> fail(ResultCode code) {
        return new R<>(code.getCode(), code.getMsg(), null);
    }
}

public enum ResultCode {

    SUCCESS(200, "成功"),
    PARAM_ERROR(400, "参数错误"),
    UNAUTHORIZED(401, "未登录"),
    FORBIDDEN(403, "无权限"),
    NOT_FOUND(404, "资源不存在"),
    SERVER_ERROR(500, "服务器异常");

    private final int code;
    private final String msg;

    ResultCode(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public int getCode() { return code; }
    public String getMsg() { return msg; }
}

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
@Component
public class Myinterpretor implements HandlerInterceptor {
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
        System.out.println("this is the postHandle method");
        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("this is the preHandle method");
        return HandlerInterceptor.super.preHandle(request, response, handler);
    }
}

//要使用拦截器，首先要添加拦截器,我们使用配置类
@Configuration
public class MyConfiguration implements WebMvcConfigurer {
    @Autowired
    Myinterpretor interpretor;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
         registry.addInterceptor(interpretor).addPathPatterns("/**");
    }
}


//多个拦截器
pre顺序执行
post倒序执行

1
2
3
4
5
6
7
8
@ExceptionHandler(ArithmeticException.class)
public String ArithmeticExceptionHandler(ArithmeticException ex){
    System.out.println("this is ArithmeticException");
    return ex.getMessage();
}

//但是这个只能在一个类中使用，出了类就不行了

1
2
3
4
5
6
7
8
9
@Configuration
public class MyConfiguration implements WebMvcConfigurer {
    @Autowired
    Myinterpretor interpretor;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
         registry.addInterceptor(interpretor).addPathPatterns("/**");
    }
}

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
@Getter
public class BizException extends RuntimeException {
    
    private final String code;
    //不用写msg ， 因为RuntimeException 自带有这个msg字段
    public BizException(BizExceptionEnum bizEnum) {
        super(bizEnum.getMsg());
        this.code = bizEnum.getCode();
    }

    public BizException(BizExceptionEnum bizEnum, Throwable cause) {
        super(bizEnum.getMsg() );
        this.code = bizEnum.getCode();
    }
}

@Getter
public enum BizExceptionEnum {

    ORDER_NOT_EXIST("100", "订单不存在"),
    PARAM_ERROR("400", "参数错误");

    private final String code;
    private final String msg;

    BizExceptionEnum(String code, String msg) {
        this.code = code;
        this.msg = msg;
    }
}

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
public class Person {
    @NotBlank(message="不能啥也没有")
    private String name;

    @NotNull
    @Max(value= 150 ,message = "不能大于150岁")
    @Min(value = 0 ,message = "不能太小了 ")
    private int age;


    @Email
    private String email;
}

//注意以上还没开启校验，需要在方法参数处使用@Valid
public void test(@RequestBody @Valid Person person,BindingResult result){
    if(result.hasErrors()){
        return ok();
    }
    Map<String,String> errorMap = new HashMap<>();
    for(FieldError fielderror:result.getFieldErrors){
        String field = fielderror.getField();
        String message = fielderror.getDefaultMessage();
        errorsMap.put(field,message);
    }
    return error(......,errorMap)
}
//上面这种方式不好，不方便
//我们不需要写，因为我们有全局异常处理器
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public String exceptionHandler(MethodArgumentNotValidException e) {
        BindingResult bindingResult = e.getBindingResult();
        Map<String,String> errorMap = new HashMap<>();
        for(FieldError fielderror : bindingResult.getFieldErrors()){
            String field = fielderror.getField();
            String message = fielderror.getDefaultMessage();
            errorMap.put(field,message);
        }
        return errorMap.keySet().toString();
    }
//直接这样封装全局的就好了
//对于异常的匹配，底层默认是精确匹配，越精确，越匹配，


//我们可以写正则表达式 
@Pattern(regexp="",message="")


//自定义校验注解
//这里了解一下有这种需求就好了，实际上我感觉挺复杂


//国际化 i18n  
@NotNul(message ="{去配置文件里面拿}")  //放在message.properties里面
配置不同语言的properties
message_zh_CN.properties

//分组校验
// 我们会说，在CRUD不同场景都会有不同的参数校验
//但是把各种注解标在field的脑子上面，各种功能放在一起不好
//所以我们有TO，DAO，VO等等
BeanUtils.copyProperties(employee,vo);
List<EmployeeRespVo> result = employees.stream().
        map(employee -> {
            var vo = new EmployeeRespVo();
            BeanUtils.copyProperties(employee,vo);
            return vo;
        })

1
2
3
4
@Tag(name = "写在类上，如：员工管理")
@Operation(summary = "add一个新员工，写在方法上")
@Schema(description = "员工表,放类上")
@Schema(description = "员工id，放field上")

1
2
3
4
5
6
7
8
9
@Mapper
public interface EmpMapper{

}
//绑定一个xml文件，一个标签就是一条sql
//注意，如果不开启驼峰映射，你就需要自己去起别名了


//注意配置mabatis.mapper-localtions = classpath:mapper/**.xml 

1
2
3
4
5
6
7
var connection = dataSource.getConnection();
// #{} 底层预编译
String sql1 = "select * from user where username = ? and password = ?"
PreparedStatement preparestatement = connection.prepareStatement(sql1);
preparestatement.setString(1,"admin");

// ${} 底层字符串拼接，有sql注入的风险

1
2
3
4
5
6
7
getEmploy(
    @Param("id") Long id,
    @Param("ext") Map<String, Object> m,
    @Param("ids") List<Long> ids,
    @Param("e") Employ e
)

1
2
3
4
5
6
7
PageHelper.startPage(1,5);
//我们调用的方法，只要紧跟着startPage，就会分页查询
List<Emp> emps = empService.getAll();
PageInfo<Emp> info = new PageInfo<>(emps); //使用info包装一下

info.getPageNum();
info.get

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Bean
public PageInterceptor getPageInterceptor() {
    var iterator = new PageInterceptor();
    Properties properties = new Properties();
    properties.setProperty("reasonable", "true"); //分页合理化，默认查P1，不会超过总页数大小
    iterator.setProperties(properties);
    return iterator;
}

@GetMapping
Result<PageInfo<AlertInfo>> alertInfoListPage(@RequestParam int begin,@RequestParam int size) {
    PageHelper.startPage(begin, size);
    List<AlertInfo> list = alterInfoService.getAllAlterInfo();
    PageInfo<AlertInfo> pageInfo = new PageInfo<>(list);
    return Result.ok(pageInfo);
}

1
2
3
4
5
6
7
mapper.selectlist(queryWrapper);
mapper.selectlist(ipage,queryWrapper);
mapper.selectById(id);
mapper.insert(entity);   //返回影响行数
mapper.updateById(entity);
mapper.deleteById(1);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//这个方式很别扭，我们用接口去继承抽象类
//那么实现类就得重写很多方法
//我们不想自己写，就继承ServiceImpl
public class UserServiceImpl<UserMapper,User> extends ServiceImpl implements UserService{

}

public interface UserService extends IService<User>{

}

userService.getById();
userService.saveOrUpdate(entity); //id存在就更新，不存在就插入
userService.saveBatch(List.of(entity1,entity2));

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
wrapper1.gt("id",1);

wrapepr2.orderByDesc("age");

wrapper3.ge().le();

wrapper4.lt().or().gt();
//使用lambda表达式
wrapper5.like().and(wrapper_ -> wrapper_.it().or().gt())
 


UpdateWrapper<TCustomer> updateWrapper = new UpdateWrapper<>()
    .setSql("balance = balance - 200")
    .in("id",ids);

updatewrapper.eq("name","hzy").set("email","fsalkdhflak@df")

lambdaquerywrapepr.eq(User::getName,"hzy")

LambdaUpdateWrapper<TCustomer>  Wrapper = new LambdaUpdateWrapper<>()
    .setSql("balance = balance - 200")
    .in(TCustomer::getId,ids);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//分页插件
@Configuration
public class MPConfiguration {

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

Ipage page1 = new Page<User>(2,3)
Ipage result = userService.page(page1);
result.getRecords().forEach(System.out::println)

userService.selectPage(page1,wrapepr1);

//自定义分页查询