SpringSpringMVCMybatis

Spring SpringMVC Mybatis学习笔记，以及Maven的学习笔记，目前正在更新中。

Spring

• SpringIOC
  • • 简介
      • Spring是分层 的JavaSE/EE应用 一站式 的 轻量级开源框架 。以 Ioc （Inverse of control）控制反转和 Aop （Aspect Oriented Programming）面向切面编程为 核心
      • 分层：
        • web层
          • web层：spring MVC框架（类似 struts2，是一个mvc框架），提供和其它web层整合方案；
        • 业务层
          • 业务层：声明式事务管理方式、任务调度；
        • 持久层
          • 持久层：jdbc模版开发工具包、和其它持久层hibernate框架整合方案；
        • 上边各层以IOC和AOP作为基础。
      • 一站式：
        • spring提供各层的解决方案。
      • 轻量级：
        • 相对于EJB来说，好用，简单、方便，spring不依赖应用服务器（weblogic）。
      • 开源框架：
        • 纯java开源框架；
        • 整合众多开源框架；
        • 和Struts2 表现层框架整合；
        • 和Hibernate 持久层框架整合；
        • 和Ibatis、Mybatis持久层框架整合 ；
        • 现在企业 90% 以上，都在使用Spring !!!!!!!
      • Spring好处
        • 1.方便解耦，简化开发：
          • Spring就是一个大工厂，可以将所有对象创建和依赖关系维护，交给Spring管理
        • 2.AOP编程的支持：
          • Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能
        • 3.声明式事务的支持：
          • 只需要通过配置就可以完成对事务的管理，而无需手动编程
        • 4.方便程序的测试：
          • Spring对Junit4支持，可以通过注解方便的测试Spring程序
        • 5.方便集成各种优秀框架：
          • Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的直接支持
        • 6.降低JavaEE API的使用难度：
          • Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低
      • spring结构体系
    • 配置文件
      • scop：指对象的取值范围
      • bean生命周期配置
      • bean实例化的三种方式：
        • • 1.
          • 2.
          • 3.
        • https://www.bilibili.com/video/BV1Bg4y1q7q2?p=11
      • bean依赖注入
        • 引用注入
          • set方法注入
          • 构造方法注入
        • 普通数据注入
          • set方法注入
          • 构造方法注入
        • 集合数据注入
          • 数组
          • List
          • Set
          • Map
    • 相关API
      • ApplicationContext的继承体系
      • Application Context的实现类
      • getbean()方法的使用
  • • 配置数据源
      • 数据源的作用
        • 经典的数据连接池配置方法
      • spring配置数据源
      • 步骤
    • 注解开发
      • spring是轻代码中配置的框架，配置比较繁重，影响开发效率，所以注解开发是一种趋势，注解代替xml配置文件可以简化配置，提高开发效率
      • 原始注解
        • • @Value
      • 新注解
        • 实例
  • Spring整合Junit
    • 简介
    • 步骤
    • 指定配置文件
    • 指定配置类
• AOP
  • SpringAOP简介
    • 什么是AOP
    • AOP的优势及其作用
    • AOP的底层实现
    • AOP的动态代理技术
    • 基于jdk的动态代理
    • cglib的动态代理
    • AOP相关概念
    • AOP开发明确的事项
    • 知识要点
  • 基于XML的AOP开发
    • 快速入门
    • 切点表达式的书写
    • 通知的类型
    • 切点表达式的抽取
    • 实例
  • 基于注解的AOP开发
    • 快速入门
    • 配置详解
      • 注解通知类型
      • 切点表达式的抽取
    • 知识要点
    • 实例
• SpringJDBCTemplate
  • 概述
  • 步骤
  • spring产生jdbctemplate对象
    • 原始版本
    • 配置提取版本
    • 更高级的版本
  • 知识要点
• 事务控制
  • 编程式事务控制
    • platformtransactionmanager
    • transactiondefinition
      • 事务的隔离级别
      • 事务传播行为
    • transactionsuatus
  • 基于XML的声明式事务控制
    • 什么是声明式事务控制
    • 声明式事务控制的实现
    • 切点事务的参数配置
  • 基于注解的声明式事务控制
    • 声明时事务控制的实现
    • 知识要点

SpringMVC

• 1. Spring集成Web环境
  • 1.1. ApplicationContext应用上下文获取
  • 1.2. Spring提供的
• 2. SpringMVC简介
  • 2.1. SpringMVC概述
    • Spring的web框架围绕DispatcherServlet设计。DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解的controller声明方式。
    • Spring MVC框架像许多其他MVC框架一样, 以请求为驱动 , 围绕一个中心Servlet分派请求及提供其他功能，DispatcherServlet是一个实际的Servlet (它继承自HttpServlet 基类)。
    • SpringMVC的原理
      • 当发起请求时被前置的控制器拦截到请求，根据请求参数生成代理请求，找到请求对应的实际控制器，控制器处理请求，创建数据模型，访问数据库，将模型响应给中心控制器，控制器使用模型与视图渲染视图结果，将结果返回给中心控制器，再将结果返回给请求者。
• 3. 深入学习
  • 3.1. 演示版本
    • SpringMVC执行原理(图为SpringMVC的一个较完整的流程图，实线表示SpringMVC框架提供的技术，不需要开发者实现，虚线表示需要开发者实现。)
      • 1. DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，DispatcherServlet接收请求并拦截请求。
        • 1. 我们假设请求的url为 : http://localhost:8080/SpringMVC/hello
        • 2. 如上url拆分成三部分：
        • 3. http://localhost:8080服务器域名
        • 4. SpringMVC部署在服务器上的web站点
        • 5. hello表示控制器
        • 6. 通过分析，如上url表示为：请求位于服务器localhost:8080上的SpringMVC站点的hello控制器。
      • 2. HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping,HandlerMapping根据请求url查找Handler。
      • 3. HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器，如上url被查找控制器为：hello。
      • 4. HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等。
      • 5. HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler。
      • 6. Handler让具体的Controller执行。
      • 7. Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView。
      • 8. HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。
      • 9. DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。
      • 10. 视图解析器将解析的逻辑视图名传给DispatcherServlet。
      • 11. DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。
      • 12. 最终视图呈现给用户。
    • 代码
  • 3.2. 注解开发
    • • 注意点
        • / 和 /* 的区别：< url-pattern > / </ url-pattern > 不会匹配到.jsp， 只针对我们编写的请求；即：.jsp 不会进入spring的 DispatcherServlet类 。< url-pattern > /* </ url-pattern > 会匹配 *.jsp，会出现返回 jsp视图 时再次进入spring的DispatcherServlet 类，导致找不到对应的controller所以报404错。
        • 注意web.xml版本问题，要最新版！
        • 注册DispatcherServlet
        • 关联SpringMVC的配置文件
        • 启动级别为1
        • 映射路径为 / 【不要用/*，会404】
    • • 注意点
        • 在视图解析器中我们把所有的视图都存放在/WEB-INF/目录下，这样可以保证视图安全，因为这个目录下的文件，客户端不能直接访问。
        • 让IOC的注解生效
        • 静态资源过滤 ：HTML . JS . CSS . 图片 ， 视频 .....
        • MVC的注解驱动
        • 配置视图解析器
    • • 注意点
        • @Controller是为了让Spring IOC容器初始化时自动扫描到；
        • @RequestMapping是为了映射请求路径，这里因为类与方法上都有映射所以访问时应该是/HelloController/hello；
        • 方法中声明Model类型的参数是为了把Action中的数据带到视图中；
        • 方法返回的结果是视图的名称hello，加上配置文件中的前后缀变成WEB-INF/jsp/hello.jsp。
  • 3.3. RestFul 风格
    • Restful就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。
    • 优点
      • 使路径变得更加简洁；
      • 获得参数更加方便，框架会自动进行类型转换。
      • 通过路径变量的类型可以约束访问参数，如果类型不一样，则访问不到对应的请求方法，如这里访问是的路径是/commit/1/a，则路径与方法不匹配，而不会是参数转换失败。
    • 示例1
      • • • 在Spring MVC中可以使用 @PathVariable 注解，让方法参数的值对应绑定到一个URI模板变量上。
    • 示例2
      • 使用RESTful操作资源 ：可以通过不同的请求方式来实现不同的效果！如下：请求地址一样，但是功能可以不同（功能又请求类型决定）！
        • http://127.0.0.1/item/1 查询,GET
        • http://127.0.0.1/item 新增,POST
        • http://127.0.0.1/item 更新,PUT
        • http://127.0.0.1/item/1 删除,DELETE
      • 用于约束请求的类型，可以收窄请求范围。指定请求谓词的类型如GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE等
    • 方法级别的注解变体有如下几个：组合注解
      • 1. @GetMapping
        • 它所扮演的是 @RequestMapping(method =RequestMethod.GET) 的一个快捷方式。
      • 2. @PostMapping
      • 3. @PutMapping
      • 4. @DeleteMapping
      • 5. @PatchMapping
  • 3.4. 数据处理及跳转
    • 跳转
      • 设置ModelAndView对象 , 根据view的名称 , 和视图解析器跳到指定的页面 .
        • 页面 : {视图解析器前缀} + viewName +{视图解析器后缀}
      • 通过SpringMVC来实现转发和重定向 - 无需视图解析器
      • 通过SpringMVC来实现转发和重定向 - 有视图解析器
    • 数据处理
      • 处理提交数据
        • 1. 提交的域名称和处理方法的参数名一致
          • 提交数据 : http://localhost:8080/hello?name=kuangshen
          • 处理方法 :
        • 2. 提交的域名称和处理方法的参数名不一致
          • 提交数据 : http://localhost:8080/hello?username=kuangshen
          • 处理方法 :
        • 3. 提交的是一个对象（要求提交的表单域和对象的属性名一致 , 参数使用对象即可）
          • 说明：如果使用对象的话，前端传递的参数名和对象名必须一致，否则就是null。
          • 实体类
          • 提交数据 : http://localhost:8080/mvc04/user？name=kuangshen&id=1&age=15
          • 处理方法 :
      • 数据显示到前端
        • 1. 通过ModelAndView
        • 2. 通过ModelMap
        • 3. 通过Model
        • 4. 对比
          • Model 只有寥寥几个方法只适合用于储存数据，简化了新手对于Model对象的操作和理解；
          • ModelMap 继承了 LinkedMap ，除了实现了自身的一些方法，同样的继承 LinkedMap 的方法和特性；
          • ModelAndView 可以在储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转。
    • 乱码问题
      • 以前乱码问题通过过滤器解决 , 而SpringMVC给我们提供了一个过滤器 , 可以在web.xml中配置 .
  • 3.5. Json交互处理
    • Jackson（java对象转json）应该是目前比较好的json解析工具了
      • 导包
      • 返回json
        • 复杂写法
        • 简单写法
          • 在类上直接使用 @RestController ，这样子，里面所有的方法都只会返回 json 字符串了，不用再每一个都添加@ResponseBody ！我们在前后端分离开发中，一般都使用 @RestController ，十分便捷！
      • 乱码问题
        • 复杂写法
        • 统一解决
          • 上一种方法比较麻烦，如果项目中有许多请求则每一个都要添加，可以通过Spring配置统一指定，这样就不用每次都去处理了！我们可以在springmvc的配置文件上添加一段消息StringHttpMessageConverter转换配置！
          • <mvc:annotation-driven> <mvc:message-converters register-defaults="true"> <bean class="org.springframework.http.converter.StringHttpMessageConverter"> <constructor-arg value="UTF-8"/> </bean> <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"> <property name="objectMapper"> <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean"> <property name="failOnEmptyBeans" value="false"/> </bean> </property> </bean> </mvc:message-converters> </mvc:annotation-driven>
    • 输出时间对象
      • 默认日期格式会变成一个数字，是1970年1月1日到当前日期的毫秒数！Jackson 默认是会把时间转成timestamps形式
      • 取消timestamps形式 ， 自定义时间格式
    • fastjson
      • fastjson.jar是阿里开发的一款专门用于Java开发的包，可以方便的实现json对象与JavaBean对象的转换，实现JavaBean对象与json字符串的转换，实现json对象与json字符串的转换。实现json的转换方法很多，最后的实现结果都是一样的。
      • fastjson 三个主要的类：
        • JSONObject 代表 json 对象
          • JSONObject实现了Map接口, 猜想 JSONObject底层操作是由Map实现的。
          • JSONObject对应json对象，通过各种形式的get()方法可以获取json对象中的数据，也可利用诸如size()，isEmpty()等方法获取"键：值"对的个数和判断是否为空。其本质是通过实现Map接口并调用接口中的方法完成的。
        • JSONArray 代表 json 对象数组
          • 内部是有List接口中的方法来完成操作的。
        • JSON代表 JSONObject和JSONArray的转化
          • JSON类源码分析与使用
          • 仔细观察这些方法，主要是实现json对象，json对象数组，javabean对象，json字符串之间的相互转化。
      • 用法

MyBatis（https://mybatis.org/mybatis-3/zh/index.html）

• 1. MyBatis简介
  • 什么是MyBatis
    • MyBatis 是一款优秀的持久层框架
    • MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集的过程
    • MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 实体类 【Plain Old Java Objects,普通的 Java对象】映射成数据库中的记录。
  • 持久化
    • 持久化是将程序数据在持久状态和瞬时状态间转换的机制。
      • 即把数据（如内存中的对象）保存到可永久保存的存储设备中（如磁盘）。持久化的主要应用是将内存中的对象存储在数据库中，或者存储在磁盘文件中、XML数据文件中等等。
      • JDBC就是一种持久化机制。文件IO也是一种持久化机制。
      • 在生活中 : 将鲜肉冷藏，吃的时候再解冻的方法也是。将水果做成罐头的方法也是。
    • 为什么需要持久化服务呢？那是由于内存本身的缺陷引起的
      • 内存断电后数据会丢失，但有一些对象是无论如何都不能丢失的，比如银行账号等，遗憾的是，人们还无法保证内存永不掉电。
      • 内存过于昂贵，与硬盘、光盘等外存相比，内存的价格要高2~3个数量级，而且维持成本也高，至少需要一直供电吧。所以即使对象不需要永久保存，也会因为内存的容量限制不能一直呆在内存中，需要持久化来缓存到外存。
  • 持久层
    • 什么是持久层？
      • 完成持久化工作的代码块 . ----> dao层 【DAO (Data Access Object) 数据访问对象】
      • 大多数情况下特别是企业级应用，数据持久化往往也就意味着将内存中的数据保存到磁盘上加以固化，而持久化的实现过程则大多通过各种关系数据库来完成。
      • 不过这里有一个字需要特别强调，也就是所谓的“层”。对于应用系统而言，数据持久功能大多是必不可少的组成部分。也就是说，我们的系统中，已经天然的具备了“持久层”概念？也许是，但也许实际情况并非如此。之所以要独立出一个“持久层”的概念,而不是“持久模块”，“持久单元”，也就意味着，我们的系统架构中，应该有一个相对独立的逻辑层面，专注于数据持久化逻辑的实现.
      • 与系统其他部分相对而言，这个层面应该具有一个较为清晰和严格的逻辑边界。【说白了就是用来操作数据库存在的！】
    • 为什么需要Mybatis
      • Mybatis就是帮助程序猿将数据存入数据库中 , 和从数据库中取数据 .
      • 传统的jdbc操作 , 有很多重复代码块 .比如 : 数据取出时的封装 , 数据库的建立连接等等... , 通过框架可以减少重复代码,提高开发效率 .
      • MyBatis 是一个半自动化的ORM框架 (Object Relationship Mapping) -->对象关系映射
      • 所有的事情，不用Mybatis依旧可以做到，只是用了它，所有实现会更加简单！技术没有高低之分，只有使用这个技术的人有高低之别
      • MyBatis的优点
        • 简单易学：本身就很小且简单。没有任何第三方依赖，最简单安装只要两个jar文件+配置几个sql映射文件就可以了，易于学习，易于使用，通过文档和源代码，可以比较完全的掌握它的设计思路和实现。
        • 灵活：mybatis不会对应用程序或者数据库的现有设计强加任何影响。sql写在xml里，便于统一管理和优化。通过sql语句可以满足操作数据库的所有需求。
        • 解除sql与程序代码的耦合：通过提供DAO层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试。sql和代码的分离，提高了可维护性。
        • 提供xml标签，支持编写动态sql。
• 2. 一个例子
  • 1. 导入相关包
  • 2. 编写mybatis核心配置文件
  • 3. 编写mybatis工具类
    • SqlSessionFactoryBuilder
      • 这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它了。 因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）。 你可以重用 SqlSessionFactoryBuilder 来创建多个 SqlSessionFactory 实例，但最好还是不要一直保留着它，以保证所有的 XML 解析资源可以被释放给更重要的事情。
    • SqlSessionFactory
      • SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。 使用 SqlSessionFactory 的最佳实践是在应用运行期间不要重复创建多次，多次重建 SqlSessionFactory 被视为一种代码“坏习惯”。因此 SqlSessionFactory 的最佳作用域是应用作用域。 有很多方法可以做到，最简单的就是使用单例模式或者静态单例模式。
  • 4. 创建实体类（成员名称与数据库对应）
  • 5. 编写mapper接口
  • 6. 编写mapper.xml配置文件(namespace 十分重要，不能写错！)
  • 7. 编写测试类
    • SqlSession
      • 每个线程都应该有它自己的 SqlSession 实例。SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。 绝对不能将 SqlSession 实例的引用放在一个类的静态域，甚至一个类的实例变量也不行。 也绝不能将 SqlSession 实例的引用放在任何类型的托管作用域中，比如 Servlet 框架中的 HttpSession。 如果你现在正在使用一种 Web 框架，考虑将 SqlSession 放在一个和 HTTP 请求相似的作用域中。 换句话说，每次收到 HTTP 请求，就可以打开一个 SqlSession，返回一个响应后，就关闭它。 这个关闭操作很重要，为了确保每次都能执行关闭操作，你应该把这个关闭操作放到 finally 块中。 下面的示例就是一个确保 SqlSession 关闭的标准模式：
• 3. CUDR及配置解析
  • CUDR
    • 接口
    • 增
    • 删
    • 改
    • 需要提交事务：session.commit();
    • 查
    • map的骚操作
    • 模糊查询
      • 安全的查询方法，用了都说好
  • 配置文件
    • 环境配置（environments）
      • MyBatis 可以配置成适应多种环境，这种机制有助于将 SQL 映射应用于多种数据库之中， 现实情况下有多种理由需要这么做。例如，开发、测试和生产环境需要有不同的配置；或者想在具有相同 Schema 的多个生产数据库中使用相同的 SQL 映射。还有许多类似的使用场景。
      • 不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。
      • 子元素节点：environment
        • 数据源（dataSource）
          • 有三种内建的数据源类型（也就是 type="[UNPOOLED|POOLED|JNDI]"）：
            • UNPOOLED– 这个数据源的实现会每次请求时打开和关闭连接。虽然有点慢，但对那些数据库连接可用性要求不高的简单应用程序来说，是一个很好的选择。 性能表现则依赖于使用的数据库，对某些数据库来说，使用连接池并不重要，这个配置就很适合这种情形。UNPOOLED 类型的数据源仅仅需要配置以下 5 种属性：
              • driver
                • – 这是 JDBC 驱动的 Java 类全限定名（并不是 JDBC 驱动中可能包含的数据源类）。
              • url
                • – 这是数据库的 JDBC URL 地址。
              • username
                • – 登录数据库的用户名。
              • password
                • – 登录数据库的密码。
              • defaultTransactionIsolationLevel
                • – 默认的连接事务隔离级别。
              • defaultNetworkTimeout
                • – 等待数据库操作完成的默认网络超时时间（单位：毫秒）。查看
              • java.sql.Connection#setNetworkTimeout()
                • 的 API 文档以获取更多信息。
              • 作为可选项，你也可以传递属性给数据库驱动。只需在属性名加上“driver.”前缀即可，例如：driver.encoding=UTF8
            • POOLED– 这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来，避免了创建新的连接实例时所必需的初始化和认证时间。 这种处理方式很流行，能使并发 Web 应用快速响应请求。
              • 除了上述提到 UNPOOLED 下的属性外，还有更多属性用来配置 POOLED 的数据源：
              • https://mybatis.org/mybatis-3/zh/configuration.html#environments
            • JNDI – 这个数据源实现是为了能在如 EJB 或应用服务器这类容器中使用，容器可以集中或在外部配置数据源，然后放置一个 JNDI 上下文的数据源引用。这种数据源配置只需要两个属性：
              • initial_context – 这个属性用来在 InitialContext 中寻找上下文（即，initialContext.lookup(initial_context)）。这是个可选属性，如果忽略，那么将会直接从 InitialContext 中寻找 data_source 属性。
              • data_source – 这是引用数据源实例位置的上下文路径。提供了 initial_context 配置时会在其返回的上下文中进行查找，没有提供时则直接在 InitialContext 中查找。
        • 事务管理器（transactionManager）
          • 在 MyBatis 中有两种类型的事务管理器（也就是 type="[JDBC|MANAGED]"）：
            • JDBC – 这个配置直接使用了 JDBC 的提交和回滚设施，它依赖从数据源获得的连接来管理事务作用域。
            • MANAGED – 这个配置几乎没做什么。它从不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）。 默认情况下它会关闭连接。然而一些容器并不希望连接被关闭，因此需要将 closeConnection 属性设置为 false 来阻止默认的关闭行为。例如: <transactionManager type="MANAGED"> <property name="closeConnection" value="false"/> </transactionManager>
          • 如果你正在使用 Spring + MyBatis，则没有必要配置事务管理器，因为 Spring 模块会使用自带的管理器来覆盖前面的配置。
    • 属性（properties）
      • 这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置。例如：
      • 设置好的属性可以在整个配置文件中用来替换需要动态配置的属性值。比如:
      • 这个例子中的 username 和 password 将会由 properties 元素中设置的相应值来替换。 driver 和 url 属性将会由 config.properties 文件中对应的值来替换。这样就为配置提供了诸多灵活选择。
      • 如果一个属性在不只一个地方进行了配置，那么，MyBatis 将按照下面的顺序来加载：
        • 首先读取在 properties 元素体内指定的属性。
        • 然后根据 properties 元素中的 resource 属性读取类路径下属性文件，或根据 url 属性指定的路径读取属性文件，并覆盖之前读取过的同名属性。
        • 最后读取作为方法参数传递的属性，并覆盖之前读取过的同名属性。
      • 从 MyBatis 3.4.2 开始，你可以为占位符指定一个默认值。例如：
        • 这个特性默认是关闭的。要启用这个特性，需要添加一个特定的属性来开启这个特性。例如：
    • 类型别名（typeAliases）
      • 类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置，意在降低冗余的全限定类名书写。例如：
        • 当这样配置时，Blog 可以用在任何使用 domain.blog.Blog 的地方。
      • 也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean，比如：
      • 每一个在包 domain.blog 中的 Java Bean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。 比如 domain.blog.Author 的别名为 author；若有注解，则别名为其注解值。见下面的例子：
    • 设置（settings）
      • 这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。
      • 必须记住的
    • typeHandlers（类型处理器）
    • objectFactory（对象工厂）
    • plugins（插件）
    • https://mybatis.org/mybatis-3/zh/configuration.html#typeHandlers
    • 映射器（mappers）
      • 既然 MyBatis 的行为已经由上述元素配置完了，我们现在就要来定义 SQL 映射语句了。 但首先，我们需要告诉 MyBatis 到哪里去找到这些语句。 在自动查找资源方面，Java 并没有提供一个很好的解决方案，所以最好的办法是直接告诉 MyBatis 到哪里去找映射文件。 你可以使用相对于类路径的资源引用，或完全限定资源定位符（包括 file:/// 形式的 URL），或类名和包名等。例如：
      • 推荐使用
      • mapper.xml
        • namespace中文意思：命名空间，作用如下：
          • namespace的命名必须跟某个接口同名
          • 接口中的方法与映射文件中sql语句id应该一一对应
  • 生命周期
    • 先分析一下Mybatis的执行过程
    • 作用域理解
      • SqlSessionFactoryBuilder 的作用在于创建 SqlSessionFactory，创建成功后，SqlSessionFactoryBuilder 就失去了作用，所以它只能存在于创建 SqlSessionFactory 的方法中，而不要让其长期存在。因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）。
      • SqlSessionFactory 可以被认为是一个数据库连接池，它的作用是创建 SqlSession 接口对象。因为 MyBatis 的本质就是 Java 对数据库的操作，所以 SqlSessionFactory 的生命周期存在于整个 MyBatis 的应用之中，所以一旦创建了 SqlSessionFactory，就要长期保存它，直至不再使用 MyBatis 应用，所以可以认为 SqlSessionFactory 的生命周期就等同于 MyBatis 的应用周期。
      • 由于 SqlSessionFactory 是一个对数据库的连接池，所以它占据着数据库的连接资源。如果创建多个 SqlSessionFactory，那么就存在多个数据库连接池，这样不利于对数据库资源的控制，也会导致数据库连接资源被消耗光，出现系统宕机等情况，所以尽量避免发生这样的情况。
      • 因此在一般的应用中我们往往希望 SqlSessionFactory 作为一个单例，让它在应用中被共享。所以说 SqlSessionFactory 的最佳作用域是应用作用域。
      • 如果说 SqlSessionFactory 相当于数据库连接池，那么 SqlSession 就相当于一个数据库连接（Connection 对象），你可以在一个事务里面执行多条 SQL，然后通过它的 commit、rollback 等方法，提交或者回滚事务。所以它应该存活在一个业务请求中，处理完整个请求后，应该关闭这条连接，让它归还给 SqlSessionFactory，否则数据库资源就很快被耗费精光，系统就会瘫痪，所以用 try...catch...finally... 语句来保证其正确关闭。
      • 所以 SqlSession 的最佳的作用域是请求或方法作用域。
• 4. ResultMap及分页
  • ResultMap
    • 测试
      • 新建一个项目
      • 结果
      • 分析
        • • select * from user where id = #{id} 可以看做
          • select id,name,pwd from user where id = #{id}
          • mybatis会根据这些查询的列名(会将列名转化为小写,数据库不区分大小写) , 去对应的实体类中查找相应列名的set方法设值 , 由于找不到setPwd() , 所以password返回null ; 【自动映射】
    • 解决方案
      • 方案一：为列名指定别名 , 别名和java实体类的属性名一致 .
      • 方案二：使用结果集映射->ResultMap 【推荐】
    • ResultMap
      • 自动映射
        • resultMap 元素是 MyBatis 中最重要最强大的元素。它可以让你从 90% 的 JDBC ResultSets 数据提取代码中解放出来。
        • 实际上，在为一些比如连接的复杂语句编写映射代码的时候，一份 resultMap 能够代替实现同等功能的长达数千行的代码。
        • ResultMap 的设计思想是，对于简单的语句根本不需要配置显式的结果映射，而对于复杂一点的语句只需要描述它们的关系就行了。
        • 你已经见过简单映射语句的示例了，但并没有显式指定resultMap。比如：
        • 上述语句只是简单地将所有的列映射到 HashMap 的键上，这由 resultType 属性指定。虽然在大部分情况下都够用，但是 HashMap 不是一个很好的模型。你的程序更可能会使用 JavaBean 或 POJO（Plain Old Java Objects，普通老式 Java 对象）作为模型。ResultMap 最优秀的地方在于，虽然你已经对它相当了解了，但是根本就不需要显式地用到他们。
      • 手动映射
        • 返回值类型为resultMap
        • 编写resultMap，实现手动映射！
  • 日志工场
    • 概述
      • 对于以往的开发过程，我们会经常使用到debug模式来调节，跟踪我们的代码执行过程。但是现在使用Mybatis是基于接口，配置文件的源代码执行过程。因此，我们必须选择日志工具来作为我们开发，调节程序的工具。Mybatis内置的日志工厂提供日志功能，具体的日志实现有以下几种工具：。具体选择哪个日志实现工具由MyBatis的内置日志工厂确定。它会使用最先找到的（按上文列举的顺序查找）。如果一个都未找到，日志功能就会被禁用。
        • SLF4J
        • Apache Commons Logging
        • Log4j 2
        • Log4j
        • JDK logging
      • 标准日志实现
    • Log4j
      • 简介：
        • Log4j是Apache的一个开源项目
        • 通过使用Log4j，我们可以控制日志信息输送的目的地：控制台，文本，GUI组件....
        • 我们也可以控制每一条日志的输出格式；
        • 通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。
      • 使用步骤：
        • 1.导包
        • 2.配置文件编写（具体配置见百度）
          • • #将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码 log4j.rootLogger=DEBUG,console,file #控制台输出的相关设置 log4j.appender.console = org.apache.log4j.ConsoleAppender log4j.appender.console.Target = System.out log4j.appender.console.Threshold=DEBUG log4j.appender.console.layout = org.apache.log4j.PatternLayout log4j.appender.console.layout.ConversionPattern=[%c]-%m%n #文件输出的相关设置 log4j.appender.file = org.apache.log4j.RollingFileAppender log4j.appender.file.File=./log/kuang.log log4j.appender.file.MaxFileSize=10mb log4j.appender.file.Threshold=DEBUG log4j.appender.file.layout=org.apache.log4j.PatternLayout log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n #日志输出级别 log4j.logger.org.mybatis=DEBUG log4j.logger.java.sql=DEBUG log4j.logger.java.sql.Statement=DEBUG log4j.logger.java.sql.ResultSet=DEBUG log4j.logger.java.sql.PreparedStatement=DEBUG ———————————————— 版权声明：本文为CSDN博主「狂神说」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/qq_33369905/article/details/106647326
        • 3、setting设置日志实现
        • 4、在程序中使用Log4j进行输出！
        • 5、测试，看控制台输出！
          • 使用Log4j 输出日志
          • 可以看到还生成了一个日志的文件 【需要修改file的日志级别】
  • 分页
    • 在学习mybatis等持久层框架的时候，会经常对数据进行增删改查操作，使用最多的是对数据库进行查询操作，如果查询大量数据的时候，我们往往使用分页进行查询，也就是每次处理小部分数据，这样对数据库压力就在可控范围内。
    • limit实现分页
      • 步骤
        • 1、修改Mapper文件
        • 2、Mapper接口，参数为map
        • 3、在测试类中传入参数测试
          • 推断：起始位置 = （当前页面 - 1 ） * 页面大小
    • RowBounds分页
    • PageHelper
    • 底层都是limit
• 5. 使用注解开发
  • 面向接口编程
    • 思想
      • 大家之前都学过面向对象编程，也学习过接口，但在真正的开发中，很多时候我们会选择面向接口编程
      • 根本原因 : 解耦 , 可拓展 , 提高复用 , 分层开发中 , 上层不用管具体的实现 , 大家都遵守共同的标准 , 使得开发变得容易 , 规范性更好
      • 在一个面向对象的系统中，系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下，各个对象内部是如何实现自己的,对系统设计人员来讲就不那么重要了；
      • 而各个对象之间的协作关系则成为系统设计的关键。小到不同类之间的通信，大到各模块之间的交互，在系统设计之初都是要着重考虑的，这也是系统设计的主要工作内容。面向接口编程就是指按照这种思想来编程。
    • 关于接口的理解
      • 接口从更深层次的理解，应是定义（规范，约束）与实现（名实分离的原则）的分离。
      • 接口的本身反映了系统设计人员对系统的抽象理解。
      • 接口应有两类：
        • 第一类是对一个个体的抽象，它可对应为一个抽象体(abstract class)；
        • 第二类是对一个个体某一方面的抽象，即形成一个抽象面（interface）；
      • 一个体有可能有多个抽象面。抽象体与抽象面是有区别的。
    • 三个面向区别
      • 面向对象是指，我们考虑问题时，以对象为单位，考虑它的属性及方法 .
      • 面向过程是指，我们考虑问题时，以一个具体的流程（事务过程）为单位，考虑它的实现 .
      • 接口设计与非接口设计是针对复用技术而言的，与面向对象（过程）不是一个问题.更多的体现就是对系统整体的架构
  • 底层
    • mybatis最初配置信息是基于 XML ,映射语句(SQL)也是定义在 XML 中的。而到MyBatis 3提供了新的基于注解的配置。不幸的是，Java 注解的的表达力和灵活性十分有限。最强大的 MyBatis 映射并不能用注解来构建
    • sql 类型主要分成 :
      • @select ()
      • @update ()
      • @Insert ()
      • @delete ()
    • 注意：利用注解开发就不需要mapper.xml映射文件了 .
    • 步骤
      • 1、我们在我们的接口中添加注解
      • 2、在mybatis的核心配置文件中注入
      • 3、我们去进行测试
      • 4、利用Debug查看本质
      • 5、本质上利用了jvm的动态代理机制
      • 6、Mybatis详细的执行流程
  • 注解增删改
    • 准备
      • 改造MybatisUtils工具类的getSession( ) 方法，重载实现。
      • 【注意】确保实体类和数据库字段对应
    • 查询：
      • 1、编写接口方法注解
      • 2、测试
    • 新增：
      • 1、编写接口方法注解
      • 2、测试
    • 修改：
      • 1、编写接口方法注解
      • 2、测试
    • 删除：
      • 1、编写接口方法注解
      • 2、测试
    • 【注意点：增删改一定记得对事务的处理】
    • 关于@Param
      • @Param注解用于给方法参数起一个名字。以下是总结的使用原则：
      • 在方法只接受一个参数的情况下，可以不使用@Param。
      • 在方法接受多个参数的情况下，建议一定要使用@Param注解给参数命名。
      • 如果参数是 JavaBean ， 则不能使用@Param。
      • 不使用@Param注解时，参数只能有一个，并且是Javabean。
    • #与$的区别
      • #{} 的作用主要是替换预编译语句(PrepareStatement)中的占位符? 【推荐使用】
      • ${} 的作用是直接进行字符串替换
  • 一个插件：LomBok
    • 以前的Java项目中，充斥着太多不友好的代码：POJO的getter/setter/toString；异常处理；I/O流的关闭操作等等，这些样板代码既没有技术含量，又影响着代码的美观，Lombok应运而生。
      • https://zhuanlan.zhihu.com/p/146659383
    • 步骤
      • 1.导包
      • 2.下插件
    • 原理：。。。
    • Lombok注解的使用
      • @Getter/@Setter: 作用类上，生成所有成员变量的getter/setter方法；作用于成员变量上，生成该成员变量的getter/setter方法。可以设定访问权限及是否懒加载等。
      • @ToString：作用于类，覆盖默认的toString()方法，可以通过of属性限定显示某些字段，通过exclude属性排除某些字段。
      • @EqualsAndHashCode：作用于类，覆盖默认的equals和hashCode
      • @AllArgsConstructor：生成全参构造器
      • @NoArgsConstructor：生成无参构造器；
      • @Data：作用于类上，是以下注解的集合：@ToString @EqualsAndHashCode @Getter @Setter @RequiredArgsConstructor
      • 常用
      • @NoArgsConstructor， @RequiredArgsConstructor， @AllArgsConstructor：作用于类上，用于生成构造函数。有staticName、access等属性。
      • staticName属性一旦设定，将采用静态方法的方式生成实例，access属性可以限定访问权限。
      • @NonNull：主要作用于成员变量和参数中，标识不能为空，否则抛出空指针异常。
      • @RequiredArgsConstructor：生成包含final和@NonNull注解的成员变量的构造器；
      • @Builder：作用于类上，将类转变为建造者模式
      • @Log：作用于类上，生成日志变量。针对不同的日志实现产品，有不同的注解：
      • 其他重要注解：
        • @Cleanup：自动关闭资源，针对实现了java.io.Closeable接口的对象有效，如：典型的IO流对象
        • @SneakyThrows：可以对受检异常进行捕捉并抛出，可以改写上述的main方法如下：
        • @Synchronized：作用于方法级别，可以替换synchronize关键字或lock锁，用处不大.
• 6. 一对多和多对一处理
  • 多对一处理
    • 前期准备
    • 按查询嵌套处理
      • 1、给StudentMapper接口增加方法
      • 2、编写对应的Mapper文件
        • • <!-- 需求：获取所有学生及对应老师的信息 思路： 1. 获取所有学生的信息 2. 根据获取的学生信息的老师ID->获取该老师的信息 3. 思考问题，这样学生的结果集中应该包含老师，该如何处理呢，数据库中我们一般使用关联查询？ 1. 做一个结果集映射：StudentTeacher 2. StudentTeacher结果集的类型为 Student 3. 学生中老师的属性为teacher，对应数据库中为tid。 多个 [1,...）学生关联一个老师=> 一对一，一对多 4. 查看官网找到：association – 一个复杂类型的关联；使用它来处理关联查询 --> <select id="FindStudent1" resultMap="StudentTeacher"> select * from student </select> <resultMap id="StudentTeacher" type="com.sk.pojo.Student"> <!--association关联属性 property属性名 javaType属性类型 column在多的一方的表中的列名--> <association property="teacher" column="tid" javaType="com.sk.pojo.Teacher" select="getTeacher"/> </resultMap> <!-- 这里传递过来的id，只有一个属性的时候，下面可以写任何值 association中column多参数配置：column="{key=value,key=value}" 其实就是键值对的形式，key是传给下个sql的取值名称，value是片段一中sql查询的字段名。 --> <select id="getTeacher" resultType="com.sk.pojo.Teacher"> select * from teacher where id = #{id} </select>
      • 3、编写完毕去Mybatis配置文件中，注册Mapper！
      • 4、注意点说明：
    • 按结果嵌套处理
      • 1、接口方法编写
      • 2、编写对应的mapper文件
        • • <!-- 按查询结果嵌套处理--> <!-- 思路：--> <!-- 1. 直接查询出结果，进行结果集的映射--> <select id="FindStudent2" resultMap="StudentTeacher2"> select s.id sid, s.name sname , t.name tname, t.id tid from student s,teacher t where s.tid = t.id </select> <resultMap id="StudentTeacher2" type="com.sk.pojo.Student"> <id property="id" column="sid"/> <result property="name" column="sname"/> <!--关联对象property 关联对象在Student实体类中的属性--> <association property="teacher" javaType="com.sk.pojo.Teacher"> <result property="id" column="tid"/> <result property="name" column="tname"/> </association> </resultMap>
      • 3、去mybatis-config文件中注入【此处应该处理过了】
  • 一对多处理
    • 前期准备
    • 按结果嵌套处理
      • 1、TeacherMapper接口编写方法
      • 2、编写接口对应的Mapper配置文件
        • • <select id="getTeacher1" resultMap="TeacherStudent"> select t.id tid,t.name tname,s.id sid,s.name sname from student s,teacher t where s.tid = t.id and t.id = #{id} </select> <resultMap id="TeacherStudent" type="com.ak.pojo.Teacher"> <result property="name" column="tname"/> <collection property="students" ofType="com.ak.pojo.Student"> <result property="id" column="sid"/> <result property="name" column="sname"/> <result property="tid" column="tid"/> </collection> </resultMap>
      • 3、将Mapper文件注册到MyBatis-config文件中
      • 4、测试
    • 按照查询嵌套处理
      • 1、TeacherMapper接口编写方法
      • 2、编写接口对应的Mapper配置文件
        • • <select id="getTeacher2" resultMap="TeacherStudent2"> select * from teacher where id = #{id} </select> <resultMap id="TeacherStudent2" type="com.ak.pojo.Teacher"> <!--column是一对多的外键 , 写的是一的主键的列名--> <collection property="students" javaType="ArrayList" ofType="com.ak.pojo.Student" column="id" select="getStudentByTeacherId"/> </resultMap> <select id="getStudentByTeacherId" resultType="com.ak.pojo.Student"> select * from student where tid = #{id} </select>
      • 3、将Mapper文件注册到MyBatis-config文件中
      • 4、测试
  • 小结
    • 1、关联-association
    • 2、集合-collection
    • 3、所以association是用于一对一和多对一，而collection是用于一对多的关系
    • 4、JavaType和ofType都是用来指定对象类型的
      • JavaType是用来指定pojo中属性的类型
      • ofType指定的是映射到list集合属性中pojo的类型。
  • 注意说明：
    • 1、保证SQL的可读性，尽量通俗易懂
    • 2、根据实际要求，尽量编写性能更高的SQL语句
    • 3、注意属性名和字段不一致的问题
    • 4、注意一对多和多对一 中：字段和属性对应的问题
    • 5、尽量使用Log4j，通过日志来查看自己的错误
• 7. 动态SQL
  • if
    • 需求：根据作者名字和博客名字来查询博客！如果作者名字为空，那么只根据博客名字查询，反之，则根据作者名来查询
    • 过程
      • 1、编写接口类
      • 2、编写SQL语句
      • 3、测试
    • 这样写我们可以看到，如果 author 等于 null，那么查询语句为 select * from user where title=#{title},但是如果title为空呢？那么查询语句为 select * from user where and author=#{author}，这是错误的 SQL 语句，如何解决呢？请看下面的 where 语句！
  • Where
    • 修改上面的SQL语句；
    • 这个“where”标签会知道如果它包含的标签中有返回值的话，它就插入一个‘where’。此外，如果标签返回的内容是以AND 或OR 开头的，则它会剔除掉。
  • Set
    • 同理，上面的对于查询 SQL 语句包含 where 关键字，如果在进行更新操作的时候，含有 set 关键词，我们怎么处理呢？
    • 过程
      • 1、编写接口方法
      • 2、sql配置文件
      • 3、测试
  • choose
    • 有时候，我们不想用到所有的查询条件，只想选择其中的一个，查询条件有一个满足即可，使用 choose 标签可以解决此类问题，类似于 Java 的 switch 语句
    • 过程
      • 1、编写接口方法
      • 2、sql配置文件
      • 3、测试类
  • SQL片段
    • 有时候可能某个 sql 语句我们用的特别多，为了增加代码的重用性，简化代码，我们需要将这些代码抽取出来，然后使用时直接调用。
    • 提取SQL片段：
    • 引用SQL片段：
    • 注意：
      • ①、最好基于 单表来定义 sql 片段，提高片段的可重用性
      • ②、在 sql 片段中不要包括 where
  • Foreach
    • 1、编写接口
    • 2、编写SQL语句
    • 3、测试
  • 小结：其实动态 sql 语句的编写往往就是一个拼接的问题，为了保证拼接准确，我们最好首先要写原生的 sql 语句出来，然后在通过 mybatis 动态sql 对照着改，防止出错。多在实践中使用才是熟练掌握它的技巧。
• 8. 缓存
  • 简介
    • 1、什么是缓存 [ Cache ]？
      • 存在内存中的临时数据。
      • 将用户经常查询的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。
    • 2、为什么使用缓存？
      • 减少和数据库的交互次数，减少系统开销，提高系统效率。
    • 3、什么样的数据能使用缓存？
      • 经常查询并且不经常改变的数据。
  • Mybatis缓存
    • MyBatis包含一个非常强大的查询缓存特性，它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。
    • MyBatis系统中默认定义了两级缓存：一级缓存和二级缓存
      • 默认情况下，只有一级缓存开启。（SqlSession级别的缓存，也称为本地缓存）
      • 二级缓存需要手动开启和配置，他是基于namespace级别的缓存。
      • 为了提高扩展性，MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存
  • 一级缓存
    • 一级缓存也叫本地缓存：
      • 与数据库同一次会话期间查询到的数据会放在本地缓存中。
      • 以后如果需要获取相同的数据，直接从缓存中拿，没必须再去查询数据库；
    • 测试
      • 1、在mybatis中加入日志，方便测试结果
      • 2、编写接口方法
      • 3、接口对应的Mapper文件
      • 4、测试
      • 5、结果分析
    • 一级缓存失效的四种情况
      • 一级缓存是SqlSession级别的缓存，是一直开启的，我们关闭不了它；
      • 一级缓存失效情况：没有使用到当前的一级缓存，效果就是，还需要再向数据库中发起一次查询请求！
      • 1、sqlSession不同
        • 观察结果：发现发送了两条SQL语句！
        • 结论：
          • 每个sqlSession中的缓存相互独立
      • 2、sqlSession相同，查询条件不同
        • 观察结果：发现发送了两条SQL语句！很正常的理解
        • 结论：
          • 当前缓存中，不存在这个数据
      • 3、sqlSession相同，两次查询之间执行了增删改操作！
        • 观察结果：查询在中间执行了增删改操作后，重新执行了
        • 结论：
          • 因为增删改操作可能会对当前数据产生影响
      • 4、sqlSession相同，手动清除一级缓存
    • 一级缓存就是一个map
  • 二级缓存
    • 二级缓存也叫全局缓存，一级缓存作用域太低了，所以诞生了二级缓存
    • 基于namespace级别的缓存，一个名称空间，对应一个二级缓存；
    • 工作机制
      • 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中；
      • 如果当前会话关闭了，这个会话对应的一级缓存就没了；但是我们想要的是，会话关闭了，一级缓存中的数据被保存到二级缓存中；
      • 新的会话查询信息，就可以从二级缓存中获取内容；
      • 不同的mapper查出的数据会放在自己对应的缓存（map）中；
    • 使用步骤
      • 1、开启全局缓存 【mybatis-config.xml】
        • <setting name="cacheEnabled" value="true"/>
      • 2、去每个mapper.xml中配置使用二级缓存，这个配置非常简单；【xxxMapper.xml】
        • 这个更高级的配置创建了一个 FIFO 缓存，每隔 60 秒刷新，最多可以存储结果对象或列表的 512 个引用，而且返回的对象被认为是只读的，因此对它们进行修改可能会在不同线程中的调用者产生冲突
      • 3、代码测试
        • 所有的实体类先实现序列化接口
        • 测试代码
    • 结论
      • 只要开启了二级缓存，我们在同一个Mapper中的查询，可以在二级缓存中拿到数据
      • 查出的数据都会被默认先放在一级缓存中
      • 只有会话提交或者关闭以后，一级缓存中的数据才会转到二级缓存中
  • 缓存原理图
  • EhCache
    • 第三方缓存实现--EhCache: 查看百度百科
    • Ehcache是一种广泛使用的java分布式缓存，用于通用缓存；
    • 要在应用程序中使用Ehcache，需要引入依赖的jar包
    • 用的时候百度
      • https://blog.csdn.net/qq_33369905/article/details/106647328?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522161675502216780261991759%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=161675502216780261991759&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_v2~rank_v29-4-106647328.nonecase&utm_term=MyBatis

Maven

• 为什么使用Maven这样的构建工具【why】
  • ① 一个项目就是一个工程
    • 如果项目非常庞大，就不适合使用package来划分模块，最好是每一个模块对应一个工程，利于分工协作。借助于maven就可以将一个项目拆分成多个工程
  • ② 项目中使用jar包，需要“复制”、“粘贴”项目的lib中
    • 同样的jar包重复的出现在不同的项目工程中，你需要做不停的复制粘贴的重复工作。借助于maven，可以将jar包保存在“仓库”中，不管在哪个项目只要使用引用即可就行。
  • ③ jar包需要的时候每次都要自己准备好或到官网下载
    • 借助于maven我们可以使用统一的规范方式下载jar包，规范
  • ④ jar包版本不一致的风险
  • 不同的项目在使用jar包的时候，有可能会导致各个项目的jar包版本不一致，导致未执行错误。借助于maven，所有的jar包都放在“仓库”中，所有的项目都使用仓库的一份jar包。
  • ⑤ 一个jar包依赖其他的jar包需要自己手动的加入到项目中
  • FileUpload组件-%26gt;IO组件，commons-fileupload-1.3.jar依赖于commons-io-2.0.1.jar
  • 极大的浪费了我们导入包的时间成本，也极大的增加了学习成本。借助于maven，它会自动的将依赖的jar包导入进来。
• maven是什么【what】
  • ① maven是一款服务于java平台的自动化构建工具
    • make-%26gt;Ant-%26gt;Maven-%26gt;Gradle
    • 名字叫法：我们可以叫妹文也可以叫麦文，但是没有叫妈文的。
  • ② 构建
    • 构建定义：把动态的Web工程经过编译得到的编译结果部署到服务器上的整个过程。
    • 编译：java源文件[.java]-%26gt;编译-%26gt;Classz字节码文件[.class]
    • 部署：最终在sevlet容器中部署的不是动态web工程，而是编译后的文件
    • 概要
  • ③ 构建的各个环节
    • 清理clean：将以前编译得到的旧文件class字节码文件删除
    • 编译compile：将java源程序编译成class字节码文件
    • 测试test：自动测试，自动调用junit程序
    • 报告report：测试程序执行的结果
    • 打包package：动态Web工程打War包，java工程打jar包
    • 安装install：Maven特定的概念-----将打包得到的文件复制到“仓库”中的指定位置
    • 部署deploy：将动态Web工程生成的war包复制到Servlet容器下，使其可以运行
• 第一个maven
  • ① 创建约定的目录结构（maven工程必须按照约定的目录结构创建）
  • 根目录：工程名 |---src：源码 |---|---main:存放主程序 |---|---|---java：java源码文件 |---|---|---resource：存放框架的配置文件 |---|---test：存放测试程序 |---pop.xml：maven的核心配置文件
• 仓库和坐标
  • ① pom.xml：
    • Project Object Model 项目对象模型。它是maven的核心配置文件，所有的构建的配置都在这里设置。
  • ② 坐标：
    • 使用下面的三个向量在仓库中唯一的定位一个maven工程
  • ③ maven工程的坐标与仓库中路径的关系：
    • maven坐标和仓库对应的映射关系：[groupId][artifactId][version][artifactId]-[version].jar
    • 去本地仓库看一下此目录：orgspringframeworkspring-core4.3.4.RELEASEspring-core-4.3.4.RELEASE.jar
    • 果然是完全对应的（默认仓库地址上面说过了哦，不要说不知道在哪，没事下面我们再说一下仓库）
  • ④ 仓库
    • 仓库的分类：
      • 1、本地仓库：
        • 当前电脑上的仓库，路径上已经说过了哦
      • 2、远程仓库：
        • 私服：搭建在局域网中，一般公司都会有私服，私服一般使用nexus来搭建。具体搭建过程可以查询其他资料
        • 中央仓库：架设在Internet上，像刚才的springframework就是在中央仓库上
• 依赖
  • ① maven解析依赖信息时会到本地仓库中取查找被依赖的jar包
    • 对于本地仓库中没有的会去中央仓库去查找maven坐标来获取jar包，获取到jar之后会下载到本地仓库
    • 对于中央仓库也找不到依赖的jar包的时候，就会编译失败了
  • ② 如果依赖的是自己或者团队开发的maven工程，需要先使用install命令把被依赖的maven工程的jar包导入到本地仓库中
    • 举例：现在我再创建第二个maven工程HelloFriend，其中用到了第一个Hello工程里类的sayHello(String name)方法。我们在给HelloFriend项目使用 mvn compile命令进行编译的时候，会提示缺少依赖Hello的jar包。怎么办呢？
    • 到第一个maven工程中执行 mvn install后，你再去看一下本地仓库，你会发现有了Hello项目的jar包。一旦本地仓库有了依赖的maven工程的jar包后，你再到HelloFriend项目中使用 mvn compile命令的时候，可以成功编译
  • ③ 依赖范围
    • scope就是依赖的范围
    • 1、compile，
      • 默认值，适用于所有阶段（开发、测试、部署、运行），本jar会一直存在所有阶段。
    • 2、provided，
      • 只在开发、测试阶段使用，目的是不让Servlet容器和你本地仓库的jar包冲突 。如servlet.jar。
    • 3、runtime，
      • 只在运行时使用，如JDBC驱动，适用运行和测试阶段。
    • 4、test，
      • 只在测试时使用，用于编译和运行测试代码。不会随项目发布。
    • 5、system，
      • 类似provided，需要显式提供包含依赖的jar，Maven不会在Repository中查找它。
• maven工程的依赖高级特性
  • ① 依赖的传递性
    • WebMavenDemo项目依赖JavaMavenService1 JavaMavenService1项目依赖JavaMavenService2
    • pom.xml文件配置好依赖关系后，必须首先mvn install后，依赖的jar包才能使用。
      • WebMavenDemo的pom.xml文件想能编译通过，JavaMavenService1必须mvn install
      • JavaMavenService的pom.xml文件想能编译通过，JavaMavenService2必须mvn install
    • 传递性
      • 注意：非compile范围的依赖是不能传递的。
  • ② 依赖版本的原则：
    • 1、路径最短者优先原则
      • Service2的log4j的版本是1.2.7版本，Service1排除了此包的依赖，自己加了一个Log4j的1.2.9的版本，那么WebMavenDemo项目遵守路径最短优先原则，Log4j的版本和Sercive1的版本一致。
    • 2、路径相同先声明优先原则
      • 这种场景依赖关系发生了变化，WebMavenDemo项目依赖Sercive1和Service2，它俩是同一个路径，那么谁在WebMavenDemo的pom.xml中先声明的依赖就用谁的版本。
  • ③ 统一管理依赖的版本：

异常

• org.springframework.beans.factory.NoSuchBeanDefinitionException
  • 是否注册组件
    • 是
      • 是否开启包扫描
        • 是
          • 重启试试（狗头）
        • 否
          • 使用注解或在配置文件中开启扫描
    • 否
      • 使用注解或在配置文件中注册
• org.springframework.aop.support.DefaultBeanFactoryPointcutAdvisor
  • 是否添加aop相关依赖
    • 否
      • 添加依赖：aspectjweaver
• mybatis绑定异常:报错BindingException: Invalid bound statement (not found):com....xxxMapper
  • 情况1：Maven静态资源过滤问题
    • pom.xml中添加：
      • <build> <resources> <resource> <directory>src/main/java</directory> <includes> <include>**/*.properties</include> <include>**/*.xml</include> </includes> <filtering>false</filtering> </resource> <resource> <directory>src/main/resources</directory> <includes> <include>**/*.properties</include> <include>**/*.xml</include> </includes> <filtering>false</filtering> </resource> </resources> </build>
  • 情况2：文件名错误
    • 排查修改即可