学习总结（2022.06.15-2022.06.24）

public interface UserService {

    public void sayHello();
}

public class UserServiceImpl implements UserService{

    @Override
    public void sayHello() {
        System.out.println("hello spring");
    }
    
}

public class CustomInvocationHandler implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return null;
    }
}

@Test
public void mytest4() {
       UserService instance = new UserServiceImpl(); // instance 👉 method.invoke(instance,args);
       // UserServiceImpl 👉 sayHello
       // Proxy 👉 sayHello
       UserService userServiceProxy = (UserService) Proxy.newProxyInstance(UserServiceImpl.class.getClassLoader(),
               UserServiceImpl.class.getInterfaces(),
               new InvocationHandler() {
                   @Override
                   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                       //jdsfkhjasdjyr
                       System.out.println("jdsfkhjasdjyr");
                       Object invoke = method.invoke(instance, args);
                       //dfjkasdhjfisdya
                       System.out.println("dfjkasdhjfisdya");
                       return invoke;
                   }
               });
       userServiceProxy.sayHello();//invocationHandler.invoke
   }

public class MyMethodInterceptor implements MethodInterceptor {
    /**
     * cglib
     *
     * @param o cglib生成的代理对象
     * @param method 被代理对象的方法
     * @param objects 方法入参
     * @param methodProxy 代理方法
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("before advice...");
        Object object = methodProxy.invokeSuper(o, objects);
        System.out.println("after advice...");
        return object;
    }
}

public class Main {
    public static void main(String[] args) {
        //通过CGLIB动态代理获取代理对象的过程
        Enhancer enhancer = new Enhancer();
        //设置enhancer对象的父类
        enhancer.setSuperclass(HelloService.class);
        //设置enhancer的回调对象
        enhancer.setCallback(new MyMethodInterceptor());
        //创建代理对象
        HelloService proxy = (HelloService) enhancer.create();
        //通过代理对象调用目标方法
        proxy.sayHello();
    }
}

@Test
public void mytest1() {
    // 初始化Spring容器
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");

    // 通过id取出组件
    UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    // 通过类型取出组件byType → class 可以写接口、实现类 → 该类型的组件在容器中只有一个
    // 建议用接口
    UserService userService1 = applicationContext.getBean(UserService.class);
    UserService userService2 = applicationContext.getBean(UserServiceImpl.class);

    // 通过id和类型共同取出
    OrderService orderService = applicationContext.getBean("orderService", OrderService.class);
}

// 通用注解
@Component

// service层
@Service

// dao层
@Repository

// controller层
@Controller

@Configuration
// @ComponentScan注解表示扫描指定包下的所有类，并将带有@Component等相关注解的类注册为组件
@ComponentScan("com.cskaoyan")
public class SpringConfiguration {

    /**
     * 返回值类型：Spring容器中的组件类型
     * 返回值：返回值注册为容器中的组件
     * 组件ID：默认值是方法名；如果想要指定组件id，可以使用@Bean的value属性
     */
    @Bean("druidDatasource")
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/cskaoyan_db");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");

        return dataSource;
    }
    /**
     * 形参：默认按照类型从容器中取出组件;想要指定组件id → @Qualifier
     */
    // 注册一个UserServiceImpl组件
    @Bean
    public UserService userService(@Qualifier("userDaoImpl") UserDao userDao) {
        UserServiceImpl userService = new UserServiceImpl();
        // 从容器中取出userDao并且给其赋值
        userService.setUserDao(userDao);
        return userService;
    }
}

@Autowired
// 如果该类型的组件不止一个，需要使用@Qualifier来指定组件的id
@Qualifier("userDaoImpl2")
UserDao userDao;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface CountTime {
}

@Aspect
@Component
public class CustomAspect {

    //@Pointcut注解增加在方法上 → value属性写切入点表达式，方法名作为切入点的id
    @Pointcut("execution(* com.cskaoyan.service..*(..))")
    public void servicePointcut() {
    }

    // 切面组件中的方法，作为对应的通知方法 → 在对应的时间点下会执行到对应的方法
    // 通知注解的value属性：可以直接写切入点表达式；也可以引用切入点方法
    @Before("servicePointcut()")
    public void beforex() {
        System.out.println("before方法");
    }

    @After("servicePointcut()")
    public void after() {
        System.out.println("after通知方法");
    }

    // Around通知 → 最强通知 ：返回值为Object，要有委托类方法的执行
    // 类似于InvocationHandler的invoke，类似于MethodInterceptor的invoke
    // 执行委托类的方法：ProceedingJoinPoint proceed方法
    @Around("servicePointcut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        System.out.println("开始时间：" + start);

        Object proceed = joinPoint.proceed(); // 执行委托类的方法

        long end = System.currentTimeMillis();
        System.out.println("方法执行时间：" + (end - start));
        return proceed; // 就是作为代理对象执行方法的返回值
    }

    // afterReturning通知方法的形参，采用Object类型，接收委托类方法的返回值
    @AfterReturning(value = "servicePointcut()",returning = "result")
    public void afterReturning(Object result) {
        System.out.println("AfterReturning接收到的结果：" + result);
    }

    // public void afterThrowing(Exception exception) {
    @AfterThrowing(value = "servicePointcut()",throwing = "exception")
    public void afterThrowing(Throwable exception) {
        System.out.println("afterThrowing通知：" + exception.getMessage());
    }
}

@Before("servicePointcut()")
public void beforex(JoinPoint joinPoint) {
    // 代理类
    Object proxy = joinPoint.getThis();
    // 目标类、委托类对象
    Object target = joinPoint.getTarget();
    // 参数
    Object[] args = joinPoint.getArgs();
    // 方法
    Signature signature = joinPoint.getSignature();
    String name = signature.getName();
    System.out.println("正在执行的方法：" + name);

    System.out.println("before方法");
}

@RequestMapping({"hello","hello2","hello3"})
   @ResponseBody
   public String hello() {
       return "hello world";
   }

/**
    * 也可以使用通配符 *
    */
   @RequestMapping({"goodbye/*", "goodbye*"})
   @ResponseBody
   public String goodbye() {
       return "byebye";
   }

@Controller
@RequestMapping("user")
public class UserController {

    //@RequestMapping("user/login")
    @RequestMapping("login") 
    @ResponseBody
    public String login() {
        return "login";
    }
    //@RequestMapping("user/register")
    @RequestMapping("register")
    @ResponseBody
    public String register() {
        return "register";
    }
    //@RequestMapping("user/modify")
    @RequestMapping("modify")
    @ResponseBody
    public String modify() {
        return "modify";
    }
    //@RequestMapping("user/remove")
    @RequestMapping("remove")
    @ResponseBody
    public String remove() {
        return "remove";
    }
}

@Controller
public class JsonController {

    @RequestMapping("json")
    @ResponseBody
    public User json() {
        return new User("123","456");
    }
}

@RequestMapping("register5")
public BaseRespVo register5(String username, String password, Integer age,
                            String[] hobbies, Integer[] ids,
                            @DateTimeFormat(pattern = "yyyy-MM-dd") Date birthday) {
    return BaseRespVo.ok();
}

@RequestMapping("file")
public BaseRespVo uploadFile(MultipartFile file) throws IOException {
    // 获得上传的文件的信息
    String name = file.getName(); // 请求参数名 → file
    String originalFilename = file.getOriginalFilename(); //原始文件名
    long size = file.getSize(); // 文件的大小
    String contentType = file.getContentType(); // 正文类型 → 文件类型
    // MultipartFile.transferTo
    File saveFile = new File("D:\\WorkSpace\\j40_workspace", originalFilename);
    //File saveFile = new File("D:\\WorkSpace\\j40_workspace\\dlrb.jpg");
    file.transferTo(saveFile);
    return BaseRespVo.ok();
}

@Data
public class User {
    String username;
   String password;
   Integer age;
    String[] hobbies;
   Integer[] ids;
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    Date birthday;
}

@RequestMapping("register6")
public BaseRespVo register6(User user) {
	return BaseRespVo.ok();
}

@RequestMapping("user/login")
public BaseRespVo login(@RequestBody JsonUser user) {
    return BaseRespVo.ok(user);
}

// 把所有Cookie都遍历打印一下
@RequestMapping("cookies")
public BaseRespVo cookies(HttpServletRequest request) {
    Cookie[] cookies = request.getCookies();
    for (Cookie cookie : cookies) {
        System.out.println(cookie.getName() + " --> " + cookie.getValue());
    }

    return BaseRespVo.ok();
}

@RequestMapping("session2")
public BaseRespVo session2(HttpSession session) {
    Object username = session.getAttribute("username");
    return BaseRespVo.ok(username);
}

@RequestMapping("note/{id}")
public BaseRespVo note(@PathVariable("id") Integer id) {
    return BaseRespVo.ok();
}

public class String2UserConverter implements Converter<String, User> {
    @Override
    public User convert(String s) {
        // 里面的转换业务需要你自己定义
        User user = new User();
        user.setUsername(s);
        user.setPassword(s);
        return user;
    }
}

// 提供自定义的转换器
@Override
public void addFormatters(FormatterRegistry registry) {
    registry.addConverter(new String2UserConverter());
}

@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
   registry.addResourceHandler("/pic/**").addResourceLocations("classpath:/");
   registry.addResourceHandler("/jpg/**").addResourceLocations("/");
	registry.addResourceHandler("/png/**").addResourceLocations("file:D:\\spring/");
}

public interface HandlerInterceptor {
    // 在Handler方法执行之前
    // 返回值为boolean，如果为true则继续流程，如果false，则中断流程
    default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return true;
    }
	// 在Handler方法执行之后
    default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
    }
	// 在整个流程完成之后
    default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
    }
}

@Component
public class CustomHandlerExceptionResolver implements HandlerExceptionResolver {
    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
        // 通过它也可以做个性化的异常处理，如果要做，需要你自己来做个性化的东西
        if (e instanceof ArithmeticException) {
            //做个性化的异常处理
            System.out.println(e.getMessage());
        }
        return new ModelAndView("/exception.jsp");
    }
}

@ControllerAdvice
public class CustomExceptionControllerAdvice {

    // 在形参中可以直接接收你抛出的异常，你映射的是什么异常，就可以以什么类型的形参来接收
    @ExceptionHandler(ArithmeticException.class)
    @ResponseBody
    public BaseRespVo method1(ArithmeticException exception) {
        return BaseRespVo.fail(exception.getMessage());
    }
    
}

// 该注解就是SpringBoot应用启动类上的注解 → 会配置扫描包目录就是该类所处的包目录
@SpringBootApplication
public class Demo1FirstSbApplication {
    // 启动类中一定会包含main方法 → 就是启动SpringBoot应用程序的入口
    public static void main(String[] args) {
        SpringApplication.run(Demo1FirstSbApplication.class, args);
    }

}

@SpringBootApplication
// 需要添加@MapperScan来扫描mapper
@MapperScan("com.cskaoyan.mapper")
public class Demo1FirstSbApplication {

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

}

//升序还是降序:字段+空格+asc(desc)
protected String orderByClause;
//去除重复:true是选择不重复记录,false,反之
protected boolean distinct;
//自定义查询条件
protected List<Criteria> oredCriteria;

@Test
public void testFindUserByName(){

    //通过criteria构造查询条件
    UserExample userExample = new UserExample();
    userExample.setOrderByClause("username asc"); //asc升序,desc降序排列
    userExample.setDistinct(false); //去除重复,true是选择不重复记录,false反之
    UserExample.Criteria criteria = userExample.createCriteria(); //构造自定义查询条件
    criteria.andUsernameEqualTo("张三");

    //自定义查询条件可能返回多条记录,使用List接收
    List<User> users = userMapper.selectByExample(userExample);

    System.out.println(users);
} 

// 类型映射配置
@MappedTypes(Integer[].class)
@MappedJdbcTypes(JdbcType.VARCHAR)
public class IntegerArrayTypeHandler implements TypeHandler<Integer[]> {

    ObjectMapper objectMapper = new ObjectMapper();
    
    // 输入映射过程
    // insert into market_user (id,username,password,role_ids) values (?,?,?,?)
    @Override
    public void setParameter(PreparedStatement preparedStatement, int index, Integer[] integers, JdbcType jdbcType) throws SQLException {
        String value = null;
        try {
            value = objectMapper.writeValueAsString(integers);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        // 为第几个占位符提供的值是什么
        preparedStatement.setString(index,value);
    }

    // 输出映射过程
    @Override
    public Integer[] getResult(ResultSet resultSet, String columName) throws SQLException {
        // 获得结果
        String result = resultSet.getString(columName);
        return transfer(result);
    }

    @Override
    public Integer[] getResult(ResultSet resultSet, int index) throws SQLException {
        // 获得结果
        String result = resultSet.getString(index);
        return transfer(result);
    }

    @Override
    public Integer[] getResult(CallableStatement callableStatement, int i) throws SQLException {
        // 获得结果
        String result = callableStatement.getString(i);
        return transfer(result);
    }

    private Integer[] transfer(String result) {
        Integer[] integers = new Integer[0];
        // 使用jackson将字符串转换Integer[]
        try {
            integers = objectMapper.readValue(result, Integer[].class);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return integers;
    }
}

@Component
public class CustomRealm extends AuthorizingRealm {
    //通常把doGetAuthenticationInfo方法放在上面

    //该方法的形参 → 来源于subject的login方法
    // 传入该值，为了根据用户名查询到该用户在系统中的密码（数据库中维护） → 来构造认证信息
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
        String username = token.getUsername();

        //根据username查询数据库中对应password
        String password = selectPasswordByUsername(username);

        // principal信息 → 当前放的是什么信息，后续取出的就是什么信息
        // 密码   → 该密码会和Token中的password做比较
        // realm名称 → 没啥用
        return new SimpleAuthenticationInfo(username,password,getName());
    }

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        // 根据用户信息拿到所有的权限（数据库）
        // doGetAuthenticationInfo方法返回值的第一个参数就是用户信息
        // 在第21行代码放入的是字符串类型的Principal信息，取出的时候就可以以字符串格式取出
        String primaryPrincipal = (String) principalCollection.getPrimaryPrincipal();
        List<String> permissions = getPermissionsByUsername(primaryPrincipal);

        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        simpleAuthorizationInfo.addStringPermissions(permissions);
        return simpleAuthorizationInfo;
    }

    private String selectPasswordByUsername(String username) {
        // 应该通过MyBatis根据用户名查询获得结果

        return "123456";
    }

    private List<String> getPermissionsByUsername(String username) {
        // 应该通过MyBatis根据用户名查询获得结果
        return Arrays.asList("admin:user:list", "admin:admin:list");
    }

}

@PostMapping("login")
public BaseRespVo<LoginUserData> login(@RequestBody Map map) {
    String username = (String)map.get("username");
    String password = (String)map.get("password");

    // 整合Shiro
    // 获得操作的主体
    Subject subject = SecurityUtils.getSubject();
    // login方法传入的参数AuthenticationToken → 认证的令牌
    // subject执行login → 认证器执行认证方法 → realm.doGetAuthenticationInfo
    // AuthenticationToken → UsernamePasswordToken → 直接封装了username和password
    // username和password通过Handler方法的形参传入
    subject.login(new UsernamePasswordToken(username,password));

    if (subject.isAuthenticated()) {
        System.out.println("认证成功");
    }

    LoginUserData loginUserData = new LoginUserData();
    AdminInfoBean adminInfo = new AdminInfoBean();
    adminInfo.setAvatar("https://wpimg.wallstcn.com/f778738c-e4f8-4870-b634-56703b4acafe.gif");
    adminInfo.setNickName("admin123");
    loginUserData.setAdminInfo(adminInfo);
    // 携带SessionId信息
    loginUserData.setToken((String) subject.getSession().getId());
    return BaseRespVo.ok(loginUserData);
}

常见的注解 （Bean Validation 中内置的 constraint）     
@Null   被注释的元素必须为 null     
@NotNull    被注释的元素必须不为 null     
@Size(max=, min=)   被注释的元素的大小必须在指定的范围内     
@AssertTrue     被注释的元素必须为 true     
@AssertFalse    被注释的元素必须为 false     
@Min(value)     被注释的元素必须是一个数字，其值必须大于等于指定的最小值     
@Max(value)     被注释的元素必须是一个数字，其值必须小于等于指定的最大值     
@DecimalMin(value)  被注释的元素必须是一个数字，其值必须大于等于指定的最小值     
@DecimalMax(value)  被注释的元素必须是一个数字，其值必须小于等于指定的最大值     
@Digits (integer, fraction)     被注释的元素必须是一个数字，其值必须在可接受的范围内     
@Past   被注释的元素必须是一个过去的日期 Date    
@Future     被注释的元素必须是一个将来的日期     
@Pattern(regex=,flag=)  被注释的元素必须符合指定的正则表达式     
Hibernate Validator 附加的 constraint     
@NotBlank(message =)   验证字符串非null，且长度必须大于0     
@Email  被注释的元素必须是电子邮箱地址     
@Length(min=,max=)  被注释的字符串的大小必须在指定的范围内     
@NotEmpty   被注释的字符串的必须非空     
@Range(min=,max=,message=)  被注释的元素必须在合适的范围内