/**
 * 1、配置类里面使用@Bean添加对象，默认是单实例
 * 2、配置类本身也是对象
 * 3、proxyBeanMethods: 代理bean的方法。默认为true(full模式)，使用代理对象调用方法，保证对象是单实例；否则(lite模式)非单实例
 */
@Configuration(proxyBeanMethods = true)  //声明这是一个配置类（即替换掉配置文件
public class MyConfig {
    // 无论外部对这个配置类中的方法调用多少次，获得的都是容器中的单实例对象
    @Bean   //向容器中添加组件，id为方法名(可以自定义)，组件类型为返回类型，组件在容器中的实例为返回地值
    public User user01() {
        return new User("zhangsan", 18);
    }
    @Bean("pet01")  //自定义id
    public Pet cat() {
        return new Pet("mimi");
    }
}

/**
 * 主程序类
 */
// 表明这是一个SpringBoot应用
@SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
        // 获取IoC容器,run声明主程序类,返回一个IoC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
        // 从容器中获取bean,默认是单实例
        User user01 = run.getBean("user01", User.class);
        Pet pet01 = run.getBean("pet01", Pet.class);
        MyConfig myConfig = run.getBean(MyConfig.class);
    }
}	

// 一下三者相当于@SpringBootApplication
@ComponentScan("com.myspringboot2")	//包扫描地址
@EnableAutoConfiguration
@SpringBootConfiguration

@Import({User.class, DBHelper.class})   //向容器中添加对应类型的对象,默认对象名为对应类的全类名

@Configuration(proxyBeanMethods = false)  //声明这是一个配置类（即替换掉配置文件
public class MyConfig {
    @ConditionalOnBean(name = "pet02")    // 按条件执行向容器中注入对象,可放在类上(则按条件执行是否注入类中所有的对象)
    @Bean   //向容器中添加组件，id为方法名(可以自定义)，组件类型为返回类型，组件在容器中的实例为返回地值
    public User user01() {
        return new User("zhangsan", 18);
    }
}

@SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
        // 获取IoC容器,run声明主程序类，返回一个IoC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
        // 由于user01配置的是由添加了ConditinalOnBean,而其中的条件pet02对象并不在容器当中，所以未注入user01
        System.out.println(run.containsBean("user01"));
    }
}

@ImportResource("classpath:beans.xml")  //兼容xml配置
@Configuration(proxyBeanMethods = false)  //声明这是一个配置类（即替换掉配置文件
public class MyConfig {
}

@SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
        // 获取IoC容器,run声明主程序类，返回一个IoC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
        // 使用@ImportResource成功注入beans.xml中的对象
        System.out.println(run.containsBean("user01"));
    }
}

@Component  //声明为组件，只有容器中的组件才能使用
@ConfigurationProperties(prefix = "mycar")  //绑定配置文件中的属性，prefix指定对应前缀
public class Car {
    String brand;
    Integer price;
	// ……
}

@EnableConfigurationProperties(Car.class)  //开启指定对象的属性配置功能
@Configuration(proxyBeanMethods = false)  //声明这是一个配置类（即替换掉配置文件
public class MyConfig {
    // ……
}

@RestController
public class HelloController {
    @Autowired
    Car car;
    @RequestMapping("/car")
    public Car car() {
        return car;
    }
}

@Configuration(proxyBeanMethods = false)
public class MyWebConfig {
    public HiddenHttpMethodFilter hiddenHttpMethodFilter() {
        HiddenHttpMethodFilter filter = new HiddenHttpMethodFilter();
        filter.setMethodParam("_m");    //修改方法参数名为_m
        return filter;
    }
}

@RestController
public class ParamTestController {

    // 测试url: http://localhost:8080/test1/1/lisi?age=10&inters=%E5%90%83%E9%A5%AD&inters=%E7%9D%A1%E8%A7%89
    @GetMapping("/test1/{id}/{username}")
    public Map<String, Object> test1(@PathVariable("id") Integer id,
                                      @PathVariable("username") String name,
                                      @PathVariable Map<String, String> variables,
                                      @RequestHeader("User-Agent") String userAgent,
                                      @RequestHeader Map<String, String> headers,
                                      @RequestParam("age") Integer age,
                                      @RequestParam("inters") List<String> inters,
                                      @RequestParam Map<String,String> params1,
                                      @RequestParam MultiValueMap<String, String> params2,
                                      @CookieValue("_xsrf") String _xsrf,
                                      @CookieValue("_xsrf") Cookie cookie) {
        /**
         * @PathVariable("") 获得指定路径变量名的值
         * @PathVariable 获得所有路径变量名以及值，存放到Map<String, String>中
         * 注意后者键值对对应的是地址栏中的username参数名，而前者是形参名name
         *
         * @RequestHeader("") 获得请求头中指定key的值
         * @RequestHeader 获得请求头中所有的key及其值
         *
         * @RequestParam("") 获得指定请求参数名的值
         * @RequestParam 获得所有请求参数名以及值，存放到Map<String, String>中
         * 注意后者存放在map中，kv只有一对，可使用MultiValueMap获取到一对多的键值对。
         */
        Map<String, Object> map = new HashMap<>();
        // 以下是测试
        map.put("id", id);
        map.put("name", name);
        map.put("pv", variables);
        map.put("userAgent", userAgent);
        map.put("rh", headers);
        map.put("age",age);
        map.put("inters",inters);
        map.put("params1",params1);
        map.put("params2",params2);
        map.put("_xsrf",_xsrf);
        System.out.println(cookie.getName()+"===>"+cookie.getValue());
        return map;
    }

    @PostMapping("/test2")
    public Map<String, Object> test2(@RequestBody String content){
       /**
         * @RequestBody 获得请求体中所有的key及对应值
         */
        Map<String, Object> map = new HashMap<>();
        // 以下是测试
        map.put("content", content);
        return map;
    }
}

@Controller //注意RestController写return "forward:/success"只会解析成字符串
public class RequestController {
    @GetMapping("/goto")
    public String gotoPage(HttpServletRequest req) {
        req.setAttribute("msg", "信息");
        req.setAttribute("code", "信息123123");
        return "forward:/success";  //转发到/success请求
    }

    @ResponseBody
    @GetMapping("/success")
    public Map<String, Object> success(@RequestAttribute("msg") String msg,
                                       @RequestAttribute("code") String code) {
    	/**
         * @RequestAttribute 获得request域对象中的指定值
         */
        Map<String, Object> map = new HashMap<>();
        map.put("msg", msg);
        map.put("code", code);
        return map;
    }
    
}

//1、矩阵变量语法： 请求路径：/cars/sell;low=34;brand=byd,audi,yd
   //2、SpringBoot默认是禁用了矩阵变量的功能
   //      手动开启：原理。对于路径的处理。UrlPathHelper进行解析。
   //              removeSemicolonContent（移除分号内容）支持矩阵变量的
   //3、矩阵变量必须有url路径变量才能被解析
   @GetMapping("/cars/{path}")
   public Map carsSell(@MatrixVariable("low") Integer low,
                       @MatrixVariable("brand") List<String> brand,
                       @PathVariable("path") String path){
       Map<String,Object> map = new HashMap<>();

       map.put("low",low);
       map.put("brand",brand);
       map.put("path",path);
       return map;
   }

   // /boss/1;age=20/2;age=10
   @GetMapping("/boss/{bossId}/{empId}")
   public Map boss(@MatrixVariable(value = "age",pathVar = "bossId") Integer bossAge,
                   @MatrixVariable(value = "age",pathVar = "empId") Integer empAge){
       Map<String,Object> map = new HashMap<>();

       map.put("bossAge",bossAge);
       map.put("empAge",empAge);
       return map;

   }

@Configuration(proxyBeanMethods = false)
public class MyWebConfig {
    public HiddenHttpMethodFilter hiddenHttpMethodFilter() {
        HiddenHttpMethodFilter filter = new HiddenHttpMethodFilter();
        filter.setMethodParam("_m");    //修改_method
        return filter;
    }

    @Bean
    // 自定义其中的功能,此处演示启用矩阵变量功能
    public WebMvcConfigurer webMvcConfigurer() {
        return new WebMvcConfigurer() {
            @Override
            public void configurePathMatch(PathMatchConfigurer configurer) {
                UrlPathHelper urlPathHelper = new UrlPathHelper();
                // 设置不删除分号内容
                urlPathHelper.setRemoveSemicolonContent(false);
                configurer.setUrlPathHelper(urlPathHelper);
            }
        };
    }
}

@Configuration(proxyBeanMethods = false)
public class MyWebConfig {
    @Bean
    // 自定义其中的功能
    public WebMvcConfigurer webMvcConfigurer() {
        return new WebMvcConfigurer() {
            @Override
            public void addFormatters(FormatterRegistry registry) {
                registry.addConverter(new Converter<String, Date>() {
                    @Override
                    public Date convert(String s) {
                        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd");
                        Date date = null;
                        try {
                            date = sf.parse(s);
                        } catch (ParseException e) {
                            e.printStackTrace();
                        }
                        return date;
                    }
                });
            }
        };
    }
}

@Controller
public class ViewTestController {
    @GetMapping("/testsuccess")
    public String test(Model model) {
        // model中的数据会被放在请求域中
        model.addAttribute("msg", "msgTest");
        model.addAttribute("link", "https://www.baidu.com");
        // 跳转页面写页面的前名
        return "success";
    }
}

/**
 * 登陆检查
 */
@Slf4j
public class LoginInterceptor implements HandlerInterceptor {
    /**
     * 目标方法执行之前
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        log.info("Run LoginInterceptor.preHandle");
        HttpSession session = request.getSession();
        Object loginUser = session.getAttribute("loginUser");
        if (loginUser != null) {
            return true;
        } else {
            session.setAttribute("msg", "当前尚未登录");
            response.sendRedirect("/");
            return false;
        }
    }
    /**
     * 目标方法执行之后
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        log.info("Run LoginInterceptor.postHandle",modelAndView);
    }
    /**
     * 页面渲染以后
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        log.info("Run LoginInterceptor.afterCompletion",ex);
    }
}

@Configuration
public class AdminWebConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 添加拦截器，并且设置拦截地址与不拦截地址
        // /**拦截目录下所有资源，静态资源也会被拦截
        registry.addInterceptor(new LoginInterceptor()).addPathPatterns("/**").excludePathPatterns("/","/login","/css/**","/js/**","/font/**","/images/**");
        // 设置exlucde不拦截，或者在配置文件中编写static-path-pattern=/static/**，注意此时需要修改标签中的href
    }
}

/**
 * 文件上传测试
 */
@Slf4j
@Controller
public class FormTestController {
    @GetMapping("/form_layouts")
    public String formLayouts() {
        return "form/form_layouts";
    }

    /**
     * MultipartFile自动封装上传过来的文件
     */
    @PostMapping("/upload")
    public String upload(@RequestParam("email") String email,
                         @RequestParam("name") String name,
                         @RequestPart("headImg") MultipartFile headImg,
                         @RequestPart("photos") MultipartFile[] photos) throws IOException {
        // 获取的信息
        log.info("上传的信息：email={},name={},headImg={},photos={}", email, name, headImg.getSize(), photos.length);
        if (!headImg.isEmpty()) {
            // 获取原文件名、保存到服务器
            headImg.transferTo(new File("C:\\Users\\卢荟\\Desktop\\test1\\"+headImg.getOriginalFilename()));
        }
        if (photos.length > 0) {
            for (MultipartFile photo : photos) {
                if (!photo.isEmpty()) {
                    photo.transferTo(new File("C:\\Users\\卢荟\\Desktop\\test2\\"+photo.getOriginalFilename()));
                }
            }
        }
        return "index";
    }
}

/**
 * 处理整个web controller的异常
 */
@Slf4j
@ControllerAdvice   //注明这是一个增强的controller
public class GlobalExceptionHandler {
    /**
     * 处理数学异常、空指针异常
     * @param e
     * @return
     */
    @ExceptionHandler({ArithmeticException.class, NullPointerException.class})   // 表明用于处理指定异常
    public String handleArithException(Exception e) {
        log.error("异常是：{}", e);
        return "error/404";      // 指定返回视图的地址
    }
}

@ResponseStatus(value = HttpStatus.FORBIDDEN,reason = "用户数量太多")     //注明异常返回状态码和原因
public class UserTooManyException extends RuntimeException {
    public UserTooManyException() {
        
    }
    public UserTooManyException(String msg) {
        super(msg);
    }
}

@Component
public class CustomerHandlerExceptionResolver implements HandlerExceptionResolver {
    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
        try {
            httpServletResponse.sendError(511, "自定义错误");
        } catch (IOException ex) {
            ex.printStackTrace();
        }
        return new ModelAndView();
    }
}

@WebServlet(urlPatterns = "/my")
public class MyServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().write("MyServlet running");
    }
}

@Slf4j
@WebFilter(urlPatterns = {"/css/*","/images/*"})
public class MyFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        log.info("MyFilter初始化");
    }
    @Override
    public void destroy() {
        log.info("MyFilter销毁");
    }
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        log.info("MyFilter running");
        filterChain.doFilter(servletRequest, servletResponse);
    }
}

@Slf4j
@WebListener
public class MyListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        log.info("MyListener监听到项目初始化完成");
    }
    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        log.info("MyListener监听到项目销毁");
    }
}

@Configuration
public class MyRegisterConfig {
    @Bean
    public ServletRegistrationBean myServlet() {
        return new ServletRegistrationBean(new MyServlet(), "/my");
    }
    @Bean
    public FilterRegistrationBean myFilter() {
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(new MyFilter());
        filterRegistrationBean.setUrlPatterns(Arrays.asList("/my","/css/*"));
        return filterRegistrationBean;
    }
    @Bean
    public ServletListenerRegistrationBean myListener() {
        return new ServletListenerRegistrationBean(new MyListener());
    }
}

@Slf4j
@SpringBootTest
class SpbAdminexApplicationTests {
    @Autowired
    JdbcTemplate jdbcTemplate;
    @Test
    void contextLoads() {
        Long count = jdbcTemplate.queryForObject("select count(*) from admin", Long.class);
        log.info("当前表的记录数为" + count);
    }
}

@Configuration
public class MyDataSourceConfig {
    // 引入自己的数据源之后，自动配置的默认DataSource失效
    @ConfigurationProperties("spring.datasource")    //将组件与配置文件中的属性绑定
    @Bean
    public DataSource dataSource() {
        DruidDataSource druidDataSource = new DruidDataSource();
        return druidDataSource;
    }
}

@Slf4j
@SpringBootTest
class SpbAdminexApplicationTests {
    @Autowired
    DataSource dataSource;
    @Test
    void contextLoads() {
        log.info("当前数据源类型为{}", dataSource.getClass());
    }
}

@Mapper //注明这是一个mapper接口
public interface AdminMapper {
    public Admin getAdmin(Integer id);
    public Boolean insertAdmin(Admin admin);
}

@Service
public class AdminService {
    @Autowired
    AdminMapper adminMapper;

    public Admin getAdminById(Integer id) {
        return adminMapper.getAdmin(id);
    }
    public Boolean insertAdmin(Admin admin) {
        return adminMapper.insertAdmin(admin);
    }
}

@Controller
public class AdminController {
    @Autowired
    AdminService adminService;
    
	@ResponseBody
    @GetMapping("/getAdmin")
    public Admin getAdminById(@RequestParam("id") Integer id) {
        return adminService.getAdminById(id);
    }
}

@Mapper //注明这是一个mapper接口
public interface AdminMapper {
    @Select("select * from admin where id=#{id}")   //注解替换beanMapper.xml文件
    public Admin getAdmin(Integer id);
}

@SpringBootApplication
@MapperScan("com.baomidou.mybatisplus.samples.quickstart.mapper")
public class Application {

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

}

@NoArgsConstructor
@AllArgsConstructor
@Data
@TableName("user")  //可以指定表名，不知道则默认为类名
public class User {
    private Long id;
    private String name;
    private String age;
    private String email;

    @TableField(exist = false)  //注明当前字段在表中不存在
    private String test;
}

public interface UserService extends IService<User> {

}

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper,User> implements UserService {

}

@Controller
public class TableController {
    @Autowired
    UserService userService = new UserServiceImpl();
    @GetMapping("/dynamic_table")
    public String dynamicTable(Model model) {
        List<User> userList = userService.list();
        model.addAttribute("userList", userList);
        return "table/dynamic_table";
    }
    @GetMapping("/responsive_table")
    public String responsiveTable() {
        return "table/responsive_table";
    }
    @GetMapping("/editable_table")
    public String editableTable() {
        return "table/editable_table";
    }
}

@Configuration
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        // 创建MybatisPlusInterceptor
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

@Controller
public class TableController {
    @Autowired
    UserService userService = new UserServiceImpl();
    
    // 进入dynamic_table并展示分页数据
	@GetMapping("/dynamic_table")
    public String dynamicTable(@RequestParam(value = "pn",defaultValue = "1")Integer pn, Model model) {
        // 获得分页结果对象，并设置分页
        Page<User> page = userService.page(new Page<User>(pn, 2));
        model.addAttribute("page", page);
        // page.getRecords获得所有记录，page.current获得当前页数，page.pages获得总页数，page.getTotal获得总条数……
        return "table/dynamic_table";
    }
    
    @GetMapping("/user/delete/{id}")
    // 删除用户功能
    public String deleteUser(@PathVariable("id") Long id,
                             @RequestParam(value = "pn",defaultValue = "1") Integer pn,
                             RedirectAttributes ra) {
        userService.removeById(id);
        ra.addAttribute("pn", pn);
        return "redirect:/dynamic_table";
    }
}

@SpringBootTest
class MyTest {
    @Test
    public void test() {
    }
}