SSM 框架 : 配置文件的 最好的学习方式 : 看官方文档 1. 简介 1.1 什么是 Mybatis MyBatis 是一款优秀的持久层框架, 它支持自定义 SQL 存储过程以及高级映射 MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作 MyBatis 可以通过简单

Transcription

1 SSM 框架 : 配置文件的 最好的学习方式 : 看官方文档 1. 简介 1.1 什么是 Mybatis MyBatis 是一款优秀的持久层框架, 它支持自定义 SQL 存储过程以及高级映射 MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作 MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型 接口和 Java POJO(Plain Old Java Objects, 普通老式 Java 对象 ) 为数据库中的记录 1.2 如何获得 Mybatis 中文文档 : maven : <! > <dependency> <groupid>org.mybatis</groupid> <artifactid>mybatis</artifactid> <version>3.5.7</version> </dependency> 1.3 持久层 数据持久化持久化就是将程序的数据在持久状态和瞬时状态转化的过程内存断电即失数据库 ( JDBC ),io 文件持久化持久层 Dao 层,service 层,controller 层完成持久化工作的代码快层级界限十分明显 1.4 为什么需要 Mybatis? 帮助程序员将数据存入到数据库中方便传统的 JDBC 代码太复杂了 简化 框架 自动化不用 Mybatis 也可以, 更容易上手 技术没有高低之分 1.5 Mybatis 第一个程序 思路流程 : 搭建环境 => 导入 Mybatis=> 编写代码 => 测试 1. 搭建数据库 CREATE DATABASE `mybatis`;

2 USE `mybatis`; DROP TABLE IF EXISTS `user`; CREATE TABLE `user` ( `id` int(20) NOT NULL, `name` varchar(30) DEFAULT NULL, `pwd` varchar(30) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8; insert into `user`(`id`,`name`,`pwd`) values (1,' 世杰 ','123456'),(2,' 张 三 ','abcdef'),(3,' 李四 ','987654'); 2. 导入 Mybatis 相关 jar 包 GitHub 上线 <! > <dependency> <groupid>org.mybatis</groupid> <artifactid>mybatis</artifactid> <version>3.5.7</version> </dependency> <! > <dependency> <groupid>mysql</groupid> <artifactid>mysql-connector-java</artifactid> <version>8.0.26</version> </dependency> <! > <dependency> <groupid>org.projectlombok</groupid> <artifactid>lombok</artifactid> <version> </version> </dependency> <!--Junit--> <dependency> <groupid>junit</groupid> <artifactid>junit</artifactid> <version>4.12</version> </dependency> 3. 编写 Mybatis 核心配置文件 查看帮助文档 <?xml version="1.0" encoding="utf-8"?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//dtd Config 3.0//EN" " <configuration> <environments default="development"> <environment id="development"> <transactionmanager type="jdbc"/>

3 <datasource type="pooled"> <property name="driver" value="com.mysql.cj.jdbc.driver"/> <property name="url" value="jdbc:mysql://localhost:3306/mybatis? servertimezone=gmt%2b8&usessl=false&useunicode=true&characterencodin g=utf-8"/> <property name="username" value="root"/> <property name="password" value="chen0215"/> </datasource> </environment> </environments> </configuration> 4. 编写 Mybatis 工具类 查看帮助文档 package com.dualseason.utils; import org.apache.ibatis.io.resources; import org.apache.ibatis.session.sqlsession; import org.apache.ibatis.session.sqlsessionfactory; import org.apache.ibatis.session.sqlsessionfactorybuilder; import java.io.ioexception; import java.io.inputstream; /** sqlsessionfactory --> sqlsession */ public class MybatisUtils { private static SqlSessionFactory sqlsessionfactory; static{ try { // 使用 Mybatis 第一步 : 获取 sqlsessionfactory 对象 String resource = "mybatis-config.xml"; InputStream inputstream = Resources.getResourceAsStream(resource); sqlsessionfactory = new SqlSessionFactoryBuilder().build(inputStream); catch (IOException e) { e.printstacktrace(); /** 既然有了 SqlSessionFactory, 顾名思义 * 我们就可以从中获取 SqlSession 的实例了 *SqlSession 完全包含了面向数据库执行 SQL 命令所需的所有方法 */ public static SqlSession getsqlsession(){ return sqlsessionfactory.opensession(); 5. 编写代码 实体类

4 import lombok.allargsconstructor; import lombok.data; @AllArgsConstructor public class User { private int id; private String name; private String pwd; Dao 接口 package com.dualseason.dao; import com.dualseason.pojo.user; import java.util.list; public interface UserDao { List<User> getuserlist(); 接口实现类 ( 由原来的 UserDaoImpl 转变成一个 Mapper 配置文件 ) <?xml version="1.0" encoding="utf-8"?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//dtd Mapper 3.0//EN" " <!--namespace 等于绑定一个对应的 Dao/Mapper 接口 --> <!-- 配置文件中 namespace 中的名称为对应 Mapper 接口或者 Dao 接口的完整包名, 必须一致!--> <mapper namespace="com.dualseason.dao.userdao"> <!--select 查询语句 --> <select id="getuserlist" resulttype="com.dualseason.pojo.user"> select * from mybatis.user; </select> </mapper> 6. 测试 package com.dualseason.dao; import com.dualseason.pojo.user; import com.dualseason.utils.mybatisutils; import org.apache.ibatis.session.sqlsession; import org.junit.test; import java.util.list; public class UserDaoTest public void test(){

5 // 第一步 : 获得 SqlSession 对象 SqlSession sqlsession = MybatisUtils.getSqlSession(); UserDao mapper = sqlsession.getmapper(userdao.class); List<User> userlist = mapper.getuserlist(); for (User user : userlist) { System.out.println(user); sqlsession.close(); 报错 : org.apache.ibatis.binding.bindingexception: Type interface com.dualseason.dao.userdao is not known to the MapperRegistry. <!-- 每一个 Mapper.xml 都要在 Mybatis 核心配置文件中注册 --> <!-- 我们要在 mybatis-config.xml 文件中加入下面代码 --> <mappers> <mapper resource="com/dualseason/dao/usermapper.xml"/> </mappers> 报错 : Caused by: org.apache.ibatis.exceptions.persistenceexception: Error building SqlSession. The error may exist in com/dualseason/dao/usermapper.xml Cause: org.apache.ibatis.builder.builderexception: Error parsing SQL Mapper Configuration. Cause: java.io.ioexception: Could not find resource com/dualseason/dao/usermapper.xml <!--maven 资源过滤 --> <!--maven 由于他的约定大于配置, 我们之后可能遇到我们写的配置文件, 无法被到处或者生效的问题, 解决方案 : --> <!-- 静态资源导出问题 --> <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>

6 </build> 我们使用 Mybatis 中可能会遇到的问题配置文件没有注册绑定接口错误方法名不对返回类型不对 Maven 导出资源问题 SqlSessionFactoryBuilder 这个类可以被实例化 使用和丢弃, 一旦创建了 SqlSessionFactory, 就不再需要它了 因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域 ( 也就是局部方法变量 ) 你可以重用 SqlSessionFactoryBuilder 来创建多个 SqlSessionFactory 实例, 但最好还是不要一直保留着它, 以保证所有的 XML 解析资源可以被释放给更重要的事情 SqlSessionFactory SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在, 没有任何理由丢弃它或重新创建另一个实例 使用 SqlSessionFactory 的最佳实践是在应用运行期间不要重复创建多次, 多次重建 SqlSessionFactory 被视为一种代码 坏习惯 因此 SqlSessionFactory 的最佳作用域是应用作用域 有很多方法可以做到, 最简单的就是使用单例模式或者静态单例模式 SqlSession 每个线程都应该有它自己的 SqlSession 实例 SqlSession 的实例不是线程安全的, 因此是不能被共享的, 所以它的最佳的作用域是请求或方法作用域 绝对不能将 SqlSession 实例的引用放在一个类的静态域, 甚至一个类的实例变量也不行 也绝不能将 SqlSession 实例的引用放在任何类型的托管作用域中, 比如 Servlet 框架中的 HttpSession 如果你现在正在使用一种 Web 框架, 考虑将 SqlSession 放在一个和 HTTP 请求相似的作用域中 换句话说, 每次收到 HTTP 请求, 就可以打开一个 SqlSession, 返回一个响应后, 就关闭它 这个关闭操作很重要, 为了确保每次都能执行关闭操作, 你应该把这个关闭操作放到 finally 块中 下面的示例就是一个确保 SqlSession 关闭的标准模式 : try (SqlSession session = sqlsessionfactory.opensession()) { // 你的应用逻辑代码 在所有代码中都遵循这种使用模式, 可以保证所有数据库资源都能被正确地关闭 映射器实例 映射器是一些绑定映射语句的接口 映射器接口的实例是从 SqlSession 中获得的 虽然从技术层面上来讲, 任何映射器实例的最大作用域与请求它们的 SqlSession 相同 但方法作用域才是映射器实例的最合适的作用域 也就是说, 映射器实例应该在调用它们的方法中被获取, 使用完毕之后即可丢弃 映射器实例并不需要被显式地关闭 尽管在整个请求作用域保留映射器实例不会有什么问题, 但是你很快会发现, 在这个作用域上管理太多像 SqlSession 的资源会让你忙不过来 因此, 最好将映射器放在方法作用域内 就像下面的例子一样 :

7 try (SqlSession session = sqlsessionfactory.opensession()) { BlogMapper mapper = session.getmapper(blogmapper.class); // 你的应用逻辑代码 2.CRUD 1 namespace namespace 中的包名要和 Dao/mapper 接口的包名一致! 2 select 选择, 查询语句 ; id : 就是对应的 namespace 中的方法名 ; resulttype:sql 语句执行的返回值! parametertype : 参数类型! 1. 编写接口 // 根据 ID 查询用户 User getuserbyid(int id); 2. 编写对应的 mapper 中的 sql 语句 <select id="getuserbyid" parametertype="int" resulttype="com.dualseason.pojo.user"> select * from user where id = #{id; </select> 3. public void getuserbyid(){ SqlSession sqlsession = MybatisUtils.getSqlSession(); UserMapper mapper = sqlsession.getmapper(usermapper.class); User user = mapper.getuserbyid(1); System.out.println(user); sqlsession.close(); 3. insert <!-- 对象中的属性, 可以直接取出来 --> <insert id="adduser" parametertype="com.dualseason.pojo.user"> insert into user(id,name,pwd) values(#{id,#{name,#{pwd); </insert>

8 4. update <update id="updateuser" parametertype="com.dualseason.pojo.user"> update user set name=#{name,pwd=#{pwd where id=#{id; </update> 5. delete <delete id="deleteuser" parametertype="int"> delete from user where id=#{id; </delete> 6. 错误分析 增删改需要提交事务 sqlsession.commit(); 7. 万能 Map 标签不要匹配错 resource 绑定 mapper 需要使用路径程序配置文件必须符合规范 NullPointerException => 没有注册到资源输出的 xml 文件中存在中文乱码问题 maven 资源导出问题 假设, 我们的实体类, 或者数据库中的表, 字段或者参数过多, 我们应当考虑使用 Map! 接口类 // 万能的 Map int adduser(map<string,object> map); xml 文件 <!-- 对象中的属性, 可以直接取出来传递 map 的 key--> <insert id="adduser" parametertype="map"> insert into user(id,pwd) values(#{userid,#{password); </insert> 测试

9 @Test public void adduser(){ SqlSession sqlsession = MybatisUtils.getSqlSession(); UserMapper mapper = sqlsession.getmapper(usermapper.class); Map<String,Object> map = new HashMap<String,Object>(); map.put("userid",5); map.put("password","123456"); mapper.adduser(map); sqlsession.commit(); sqlsession.close(); Map 传递参数, 直接在 sql 中取出 key 即可! parametertype="map" 对象传递参数, 直接在 sql 中取对象的属性即可! parametertype="object" 只有一个基本类型参数的情况下, 可以直接在 sql 中取到多个参数用 Map, 或者注解 8. 思考题 模糊查询怎么写? 1. Java 代码执行的时候, 传递通配符 %% List<User> userlist = mapper.getuserlike("% 李 %"); 2. 在 sql 拼接中使用通配符 select * from user where name like "%"#{value"%"; 3. 配置解析 1. 核心配置文件 myabtis-config.xml Mybatis 的配置文件包含了会深深影响 Mybatis 行为的设置和属性信息 configuration( 配置 ) properties( 属性 ) settings( 设置 ) typealiases( 类型别名 ) typehandlers( 类型处理器 )

10 objectfactory( 对象工厂 ) plugins( 插件 ) environments( 环境配置 ) environment( 环境变量 ) transactionmanager( 事务管理器 ) datasource( 数据源 ) databaseidprovider( 数据库厂商标识 ) mappers( 映射器 ) 2. 环境配置 (environments) Mybatis 可以配置成适应多种环境不过要记住 : 尽管可以配置多个环境, 但每个 SqlSessionFactory 实例只能选择一种环境 学会使用配置多套运行环境! Mybatis 默认的事务管理器就是 JDBC, 连接池 : POOLED 3. 属性 (properties) 我们直接上例子来看, 首先写一个 database.properties database.properties jdbc.driver=com.mysql.cj.jdbc.driver jdbc.url=jdbc:mysql://localhost:3306/mybatis? servertimezone=gmt%2b8&usessl=false&useunicode=true&characterencoding=utf-8 jdbc.username=root jdbc.password= 密码 在核心配置文件中引入 <!-- 引入外部配置文件 --> <properties resource="database.properties"> <property name="username" value="root"/> <property name="pwd" value=" 密码 "/> </properties> 可以直接引入外部文件可以在其中增加一些属性配置如果两个文件有同一个字段, 优先使用外部配置文件的 4. 类型别名 (typealiases) 类型别名是为 Java 类型设置一个短的名字存在的意义仅在用来减少类完全限定名的冗余 <!-- 可以给实体类起别名 --> <typealiases> <typealias type="com.dualseason.pojo.user" alias="user"/> </typealiases>

11 也可以指定一个包名,Mybatis 会在包名下面搜索需要的 Java Bean, 比如 : 扫描实体类的包, 它的默认别名就为这个类的类名, 首字母小写! <!-- 可以给实体类起别名 --> <typealiases> <package name="com.dualseason.pojo"/> </typealiases> 在实体类比较少的时候, 使用第一种方式 如果实体类十分多, 建议使用第二种 第一种可以 DIY 别名, 第二种则不行, 如果非要改, public class User{ 5. 设置设置 (settings) 这是 MyBatis 中极为重要的调整设置, 它们会改变 MyBatis 的运行时行为 下表描述了设置中各项设置的含义 默认值等

12 设置名描述有效值默认值 cacheenabled 全局性地开启或关闭所有映射器配置文件中已配置的任何缓存 true false true lazyloadingenabled 延迟加载的全局开关 当开启时, 所有关联对象都会延迟加载 特定关联关系中可通过设置 fetchtype 属性来覆盖该项的开关状态 true false false aggressivelazyloading 开启时, 任一方法的调用都会加载该对象的所有延迟加载属性 否则, 每个延迟加载属性会按需加载 ( 参考 lazyloadtriggermethods) true false false ( 在 及之前的版本中默认为 true) multipleresultsetsenabled 是否允许单个语句返回多结果集 ( 需要数据库驱动支持 ) true false true usecolumnlabel 使用列标签代替列名 实际表现依赖于数据库驱动, 具体可参考数据库驱动的相关文档, 或通过对比测试来观察 true false true usegeneratedkeys 允许 JDBC 支持自动生成主键, 需要数据库驱动支持 如果设置为 true, 将强制使用自动生成主键 尽管一些数据库驱动不支持此特性, 但仍可正常工作 ( 如 Derby) true false False automappingbehavior 指定 MyBatis 应如何自动映射列到字段或属性 NONE 表示关闭自动映射 ;PARTIAL 只会自动映射没有定义嵌套结果映射的字段 FULL 会自动映射任何复杂的结果集 ( 无论是否嵌套 ) NONE, PARTIAL, FULL PARTIAL automappingunknowncolumnbehavior 指定发现自动映射目标未知列 ( 或未知属性类型 ) 的行为 NONE: 不做任何反应 WARNING: 输出警告日志 ('org.apache.ibatis.session.automappingunknowncolumnbehavior' 的日志等级必须设置为 WARN)FAILING: 映射失败 ( 抛出 SqlSessionException) NONE, WARNING, FAILING NONE defaultexecutortype 配置默认的执行器 SIMPLE 就是普通的执行器 ;REUSE 执行器会重用预处理语句 (PreparedStatement); BATCH 执行器不仅重用语句还会执行批量更新 SIMPLE REUSE BATCH SIMPLE defaultstatementtimeout 设置超时时间, 它决定数据库驱动等待数据库响应的秒数 任意正整数未设置 (null) defaultfetchsize 为驱动的结果集获取数量 (fetchsize) 设置一个建议值 此参数只可以在查询设置中被覆盖 任意正整数未设置 (null) defaultresultsettype 指定语句默认的滚动策略 ( 新增于 3.5.2) FORWARD_ONLY SCROLL_SENSITIVE SCROLL_INSENSITIVE DEFAULT( 等同于未设置 ) 未设置 (null) saferowboundsenabled 是否允许在嵌套语句中使用分页 (RowBounds) 如果允许使用则设置为 false true false False saferesulthandlerenabled 是否允许在嵌套语句中使用结果处理器 (ResultHandler) 如果允许使用则设置为 false true false True mapunderscoretocamelcase 是否开启驼峰命名自动映射, 即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 acolumn true false False localcachescope MyBatis 利用本地缓存机制 (Local Cache) 防止循环引用和加速重复的嵌套查询 默认值为 SESSION, 会缓存一个会话中执行的所有查询 若设置值为 STATEMENT, 本地缓存将仅用于执行语句, 对相同 SqlSession 的不同查询将不会进行缓存 SESSION STATEMENT SESSION jdbctypefornull 当没有为参数指定特定的 JDBC 类型时, 空值的默认 JDBC 类型 某些数据库驱动需要指定列的 JDBC 类型, 多数情况直接用一般类型即可, 比如 NULL VARCHAR 或 OTHER JdbcType 常量, 常用值 :NULL VARCHAR 或 OTHER OTHER lazyloadtriggermethods 指定对象的哪些方法触发一次延迟加载 用逗号分隔的方法列表 equals,clone,hashcode,tostring defaultscriptinglanguage 指定动态 SQL 生成使用的默认脚本语言 一个类型别名或全限定类名 org.apache.ibatis.scripting.xmltags.xmllanguagedriver defaultenumtypehandler 指定 Enum 使用的默认 TypeHandler ( 新增于 3.4.5) 一个类型别名或全限定类名 org.apache.ibatis.type.enumtypehandler callsettersonnulls 指定当结果集中值为 null 的时候是否调用映射对象的 setter(map 对象时为 put) 方法, 这在依赖于 Map.keySet() 或 null 值进行初始化时比较有用 注意基本类型 (int boolean 等 ) 是不能设置成 null 的 true false false returninstanceforemptyrow 当返回行的所有列都是空时,MyBatis 默认返回 null 当开启这个设置时,MyBatis 会返回一个空实例 请注意, 它也适用于嵌套的结果集 ( 如集合或关联 ) ( 新增于 3.4.2) true false false logprefix 指定 MyBatis 增加到日志名称的前缀 任何字符串未设置 logimpl 指定 MyBatis 所用日志的具体实现, 未指定时将自动查找 SLF4J LOG4J LOG4J2 JDK_LOGGING COMMONS_LOGGING STDOUT_LOGGING NO_LOGGING 未设置 proxyfactory 指定 Mybatis 创建可延迟加载对象所用到的代理工具 CGLIB JAVASSIST JAVASSIST (MyBatis 3.3 以上 ) vfsimpl 指定 VFS 的实现 自定义 VFS 的实现的类全限定名, 以逗号分隔 未设置 useactualparamname 允许使用方法签名中的名称作为语句参数名称 为了使用该特性, 你的项目必须采用 Java 8 编译, 并且加上 -parameters 选项 ( 新增于 3.4.1) true false true configurationfactory 指定一个提供 Configuration 实例的类 这个被返回的 Configuration 实例用来加载被反序列化对象的延迟加载属性值 这个类必须包含一个签名为 static Configuration getconfiguration() 的方法 ( 新增于 3.2.3) 一个类型别名或完全限定类名 未设置 shrinkwhitespacesinsql 从 SQL 中删除多余的空格字符 请注意, 这也会影响 SQL 中的文字字符串 ( 新增于 3.5.5) true false false defaultsqlprovidertype Specifies an sql provider class that holds provider method (Since 3.5.6). This class apply to the type(or value) attribute on sql provider when these attribute was omitted. A type alias or fully qualified class name Not set 一个配置完整的 settings 元素的示例如下 : <settings> <setting name="cacheenabled" value="true"/> <setting name="lazyloadingenabled" value="true"/> <setting name="multipleresultsetsenabled" value="true"/> <setting name="usecolumnlabel" value="true"/> <setting name="usegeneratedkeys" value="false"/> <setting name="automappingbehavior" value="partial"/> <setting name="automappingunknowncolumnbehavior" value="warning"/> <setting name="defaultexecutortype" value="simple"/> <setting name="defaultstatementtimeout" value="25"/> <setting name="defaultfetchsize" value="100"/> <setting name="saferowboundsenabled" value="false"/>

13 <setting name="mapunderscoretocamelcase" value="false"/> <setting name="localcachescope" value="session"/> <setting name="jdbctypefornull" value="other"/> <setting name="lazyloadtriggermethods" value="equals,clone,hashcode,tostring"/> </settings> 6. 其他配置 typehandlers( 类型处理器 ) objectfactory( 对象工厂 ) plugins 插件 mybatis-generator-core mybatis-plus 通用 mapper 7. 映射器 (mappers) MapperRegistry : 注册绑定我们的 Mapper 文件方式一 : 推荐使用 <!-- 每一个 Mapper XML 都需要在 Mybatis 核心配置文件中注册!--> <mappers> <mapper resource="com/dualseason/dao/usermapper.xml"/> </mappers> 方式二 : 使用 class 文件绑定注册 <!-- 每一个 Mapper.xml 都需要在 Myabtis 核心配置文件中进行注册!--> <mappers> <mapper class="com.dualseason.dao.usermapper"/> </mappers> 注意点 : 接口和他的 Mapper 配置文件必须同名接口和他的 Mapper 配置文件必须在同一个包下方式三 : 使用扫描包进行注入绑定 <mappers> <package name="com.dualseason.dao"/> </mappers> 注意点 : 接口和他的 Mapper 配置文件必须同名接口和他的 Mapper 配置文件必须在同一个包下练习 :

14 将数据库配置文件外部引入实体类别名保重 UserMapper 接口和 UserMapper.xml 改为一致! 并且放在同一个包下 8. 生命周期和作用域 生命周期和作用域是至关重要的, 因为错误的使用会导致非常严重的并发问题 SqlSessionFactoryBuilder : 一旦创建了 SqlSessionFactory, 就不再需要它了局部变量 SqlSessionFactory : 说白了就是可以想象为数据库连接池 SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在, 没有任何理由丢弃它或重新创建另一个实例 因此 SqlSessionFactory 的最佳作用域是应用作用域最简单的就是使用单例模式或者静态单例模式 SqlSession 连接到连接池的一个请求 SqlSession 的实例不是线程安全的, 因此是不能被共享的, 所以它的最佳作用域是请求或方法作用域用完之后需要赶紧关闭, 否则资源被占用 4. 解决属性名和字段名不一致的问题 1. 起别名 <select id="getuserbyid" resulttype="com.dualseason.user"> select id,name,pwd as password from user where id = #{id </select> 2. resultmap 结果集映射 id name pwd id name password <!-- 结果集映射 --> <resultmap id="usermap" type="user"> <!--column 数据库中的字段,property 实体类中的属性 --> <result column="id" property="id"/> <result column="name" property="name"/> <result column="pwd" property="password"/> </resultmap> <select id="getuserbyid" resultmap="usermap"> select * from user where id = #{id; </select>

15 5. 分页 resultmap 元素是 Mybatis 中最重要强大的元素 ResultMap 的设计思想是, 对于简单的语句更笨不需要配置显式的结果映射, 而对于复杂一点的语句只需要描述他们的关系就行了 ResultMap 最优秀的地方在于, 虽然你已经对它相当了解了, 但根本不需要显式地用到他们 1. 使用 Limit 分页 -- 语法 select * from user limit startindex,pagesize; select * from user limit 3; -- 相当于 #[0,3] 使用 Mybatis 实现分页, 核心 SQL 1. 接口 // 分页 List<User> getuserbylimit(map<string,interger> map); 2. Mapper.xml <!-- 分页 --> <select id="getuserbylimit" parametertype="map" resultmap="usermap"> select * from user limit #{startindex,#{pagesize; </select> 3. public void getuserbylimit(){ SqlSession sqlsession = MybatisUtils.getSqlSession(); UserMapper mapper = sqlsession.getmapper(usermapper.class); HashMap<String,Integer> map = new HashMap<String,Integer>(); map.put("startindex",1); map.put("pagesize",2); List<User> userlist = mapper.getuserbylimit(map); for(user user : userlist){ System.out.println(user); sqlsession.close(); 2. RowBounds 分页 不再使用 SQL 实现分页

16 1. 接口 // 分页 2 List<User> getuserbyrowbounds(); 2. mapper.xml <!-- 分页 --> <select id="getuserbyrowbounds" resultmap="usermap"> select * from user; </select> 3. public void getuserbyrowbounds(){ SqlSession sqlsession = MybatisUtils.getSqlSession(); //RowBounds 实现 RowBounds rowbounds = new RowBounds(1,2); List<User> userlist = sqlsession.selectlist("com.dualseason.dao.usermapper.getuserbyrowbounds",null,ro wbounds); for(user user : userlist){ System.out.println(user); sqlsession.close(); 3. 分页插件 PageHelper 6. 使用注解开发 面向接口编程 : 解耦, 可拓展, 提高复用, 分层开发中, 上层不用管具体的实现, 大家都遵守共同的标准, 使得开发变得容易, 规范性更好接口从更深层次的理解, 应是定义 ( 规范, 约束 ) 与实现 ( 名实分离原则 ) 的分离接口的本身反应了系统设计人员对系统的抽象理解接口应该有两个类第一类是对一个个体的抽象, 它可对应成为一个抽象体 (abstract class) 第二类是对一个个体某一方面的抽象, 即形成一个抽象面 (interface) 一个个体可能有多个抽象面抽象体与抽象面是有区别的三个面向的区别面向对象是指我们考虑问题的时候以对象为单位, 考虑它的属性以及方法面向过程是指我们考虑问题时, 以一个具体的流程 ( 事务过程 ) 为单位, 考虑它的实现

17 接口设计与非接口设计是针对复用技术而言的, 与面向对象 ( 过程 ) 不是一个问题, 更多的是提现就是对系统整体的架构 1. 使用注解开发 1. * from user") List<User> getuser(); 2. 需要在核心配置文件中绑定接口 <!-- 绑定接口 --> <mappers> <mapper class="com.dualseason.dao.usermapper"/> </mappers> 2. CRUD 我们可以在工具类创建的时候实现自动提交事务 public static SqlSession getsqlsession(){ return sqlsessionfactory.opensession(true); 编写接口, 增加注解 public interface UserMapper * from user") List<User> getusers(); // 方法存在多个参数, * from user where id = #{id") User getuserbyid(@param("id") int into user(id,name,pwd) values(#{id,#{name,#{password)") int adduser(user user set name = #{name,pwd = #{password where id = #{id") int updateuser(user from user where id = #{uid") int deleteuser(@param("uid") int id); 测试类 我们必须将接口注册绑定到我们的核心配置文件 ( 如 mybatis-config.xml) 注解

18 基本类型的参数或者 String 类型必须加上引用类不需要加如果只有一个基本类的话, 可以忽略, 但是建议加上我们在 SQL 中设定的属性名 7. 多对一处理 1. 多个学生, 对应一个老师 2. 对于学生这边而言, 关联.. 多个学生, 关联一个老师 多对一 3. 对于老师而言, 集合, 一个老师, 有很多学生 一对多 CREATE TABLE `teacher` ( `id` INT(10) NOT NULL, `name` VARCHAR(30) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=INNODB DEFAULT CHARSET=utf8 INSERT INTO teacher(`id`, `name`) VALUES (1, ' 世杰 '); CREATE TABLE `student` ( `id` INT(10) NOT NULL, `name` VARCHAR(30) DEFAULT NULL, `tid` INT(10) DEFAULT NULL, PRIMARY KEY (`id`), KEY `fktid` (`tid`), CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`) ) ENGINE=INNODB DEFAULT CHARSET=utf8 INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('1', ' 小明 ', '1'); INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('2', ' 小红 ', '1'); INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('3', ' 小张 ', '1'); INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('4', ' 小李 ', '1'); INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('5', ' 小王 ', '1'); 1. 测试环境搭建 1. 导入 lombok 2. 新建实体类 Teacher,Student 3. 建立 Mapper 接口 4. 建立 Mapper.xml 文件 5. 在核心配置文件中绑定注册我们的 Mapper 接口或者文件 6. 测试查询是否能够成功 2. 按照查询嵌套处理 <!-- 思路 : 1. 查询所有的学生信息 2. 根据查询出来的学生的 tid, 寻找对应的老师! 子查询 --> <select id="getstudent" resultmap="studentteacher"> select * from student; </select>

19 <resultmap id="studentteacher" type="student"> <result property="id" column="id"/> <result property="name" column="name"/> <!-- 复杂的属性, 我们需要单独处理对象 : association 集合 : collection --> <association property="teacher" column="tid" javatype="teacher" select="getteacher"/> </resultmap> <select id="getteacher" resulttype="teacher"> select * from teacher where id = #{id </select> 3. 按照结果嵌套处理 <select id="getstudent" resultmap="studentteacher"> select s.id sid,s.name sname,t.name tname from student s,teacher t where s.tid = t.id; </select> <resultmap id="studentteacher" type="student"> <result property="id" column="sid"/> <result property="name" column="sname"/> <association property="teacher" javatype="teacher"> <result property="name" column="tname"/> </association> </resultmap> 8. 一对多处理 public class Student { private int id; private String name; private int public class Teacher { private int id; private String name; // 一个老师拥有多个学生 private List<Student> students; 1. 按照结果嵌套处理 <!-- 按结果嵌套查询 --> <select id="getteacher" resultmap="teacherstudent">

20 select s.id sid, s.name sname, t.name tname,t.id tid from student s,teacher t where s.tid = t.id and t.id = #{tid </select> <resultmap id="teacherstudent" type="teacher"> <result property="id" column="tid"/> <result property="name" column="tname"/> <!-- 复杂的属性, 我们需要单独处理对象 : association 集合 : collection javatype="" 指定属性的类型! 集合中的泛型信息, 我们使用 oftype 获取 --> <collection property="students" oftype="student"> <result property="id" column="sid"/> <result property="name" column="sname"/> <result property="tid" column="tid"/> </collection> </resultmap> 2. 按照查询嵌套处理 <select id="getteacher" resultmap="teacherstudent"> select * from teacher where id = #{id; </select> <resultmap id="teacherstudent" type="teacher"> <collection property="students" javatype="arraylist" oftype="student" select="getstudentbyteacherid" column="id"/> </resultmap> <select id="getstudentbyteacherid" resulttype="student"> select * from student where id = #{id; </select> 小结 注意点 1. 关联 => association ( 多对一 ) 2. 集合 => collection ( 一对多 ) 3. javatype & oftype 1. javatype 用来指定实体类中属性的类型 2. oftype 用来指定映射到 List 或者集合中的 pojo 类型, 泛型中的约束类型 9. 动态 SQL 保证 SQL 的可读性, 尽量保证通俗易懂注意一对多和多对一中属性名和字段的问题如果问题不好排查错误, 可以使用日志, 建议使用 Log4j 或者 SLF4J 什么是动态 SQL : 动态 SQL 就是根据不同的条件生成不同的 SQL 语句 搭建环境

21 CREATE TABLE `blog` ( `id` varchar(50) NOT NULL COMMENT ' 博客 id', `title` varchar(100) NOT NULL COMMENT ' 博客标题 ', `author` varchar(30) NOT NULL COMMENT ' 博客作者 ', `create_time` datetime NOT NULL COMMENT ' 创建时间 ', `views` int(30) NOT NULL COMMENT ' 浏览量 ' ) ENGINE=InnoDB DEFAULT CHARSET=utf8 创建一个基础工程 1. 导包 2. 编写配置文件 3. public class Blog { private int id; private String title; private String author; private Date createtime; private int views; IF 4. 编写实体类对应 Mapper 接口和 Mapper.XML 文件 <select id="queryblogif" parametertype="map" resulttype="blog"> select * from blog where 1 = 1 <if test="title!= null"> and title = #{title </if> <if test="author!= null"> and author = #{author </if> </select> choose(when,otherwise) <select id="queryblogchoose" parametertype="map" resulttype="blog"> select * from blog <where> <choose> <when test="title!= null"> title = #{title </when> <when test="author!= null"> and author = #{author

22 </when> <otherwise> and views = #{views </otherwise> </choose> </where> </select> trim(where,set) select * from blog <where> <if test="title!= null"> title = #{title </if> <if test="author!= null"> and author = #{author </if> </where> <update id="updateblog" parametertype="map"> update mybatis.blog <set> <if test="title!= null"> title = #{title, </if> <if test="author!= null"> author = #{author </if> </set> where id = #{id </update> 所谓的动态 SQL, 本质还是 SQL 语句, 只是我们可以在 SQL 层面, 去执行一个逻辑代码 if,where, set, choose,when SQL 片段 有的时候, 我们可能会将一些功能的部分抽取出来, 方便复用! 1. 使用 SQL 标签抽取公共的部分 <sql id="if-title-author"> <if test="title!= null"> title = #{title </if> <if test="author!= null"> and author = #{author </if> </sql>

23 2. 在需要使用的地方使用 Include 标签引用即可 <select id="queryblogif" parametertype="map" resulttype="blog"> select * from mybatis.blog <where> <include refid="if-title-author"></include> </where> </select> 注意事项 : 最好基于单表来定义 SQL 片段! 不要存在 where 标签 Foreach select * from user where 1=1 and <foreach item="id" collection="ids" open="(" separator="or" close=")"> #{id </foreach> (id=1 or id=2 or id=3) <!-- select * from mybatis.blog where 1=1 and (id=1 or id = 2 or id=3) --> 我们现在传递一个万能的 map, 这 map 中可以存在一个集合! <select id="queryblogforeach" parametertype="map" resulttype="blog">

24 select * from mybatis.blog <where> <foreach collection="ids" item="id" open="and (" close=")" separator="or"> id = #{id </foreach> </where> </select> 了 动态 SQL 就是在拼接 SQL 语句, 我们只要保证 SQL 的正确性, 按照 SQL 的格式, 去排列组合就可以 建议 : 现在 Mysql 中写出完整的 SQL, 再对应的去修改成为我们的动态 SQL 实现通用即可! 13 缓存 ( 了解 ) 13.1 简介 查询 : 连接数据库, 耗资源! 一次查询的结果, 给他暂存在一个可以直接取到的地方!--> 内存 : 缓存 我们再次查询相同数据的时候, 直接走缓存, 就不用走数据库了 1. 什么是缓存 [ Cache ]? 存在内存中的临时数据 将用户经常查询的数据放在缓存 ( 内存 ) 中, 用户去查询数据就不用从磁盘上 ( 关系型数据库数据文件 ) 查询, 从缓存中查询, 从而提高查询效率, 解决了高并发系统的性能问题 2. 为什么使用缓存? 减少和数据库的交互次数, 减少系统开销, 提高系统效率 3. 什么样的数据能使用缓存? 经常查询并且不经常改变的数据 可以使用缓存 13.2 Mybatis 缓存 MyBatis 包含一个非常强大的查询缓存特性, 它可以非常方便地定制和配置缓存 缓存可以极大的提升查询效率 MyBatis 系统中默认定义了两级缓存 : 一级缓存和二级缓存默认情况下, 只有一级缓存开启 (SqlSession 级别的缓存, 也称为本地缓存 ) 二级缓存需要手动开启和配置, 他是基于 namespace 级别的缓存

25 为了提高扩展性,MyBatis 定义了缓存接口 Cache 我们可以通过实现 Cache 接口来 自定义二级缓存 13.3 一级缓存 一级缓存也叫本地缓存 : SqlSession 与数据库同一次会话期间查询到的数据会放在本地缓存中 以后如果需要获取相同的数据, 直接从缓存中拿, 没必须再去查询数据库 ; 测试步骤 : 1. 开启日志! 2. 测试在一个 Sesion 中查询两次相同记录 3. 查看日志输出 缓存失效的情况 : 1. 查询不同的东西 2. 增删改操作, 可能会改变原来的数据, 所以必定会刷新缓存! 3. 查询不同的 Mapper.xml 4. 手动清理缓存!

26 段! 小结 : 一级缓存默认是开启的, 只在一次 SqlSession 中有效, 也就是拿到连接到关闭连接这个区间 一级缓存就是一个 Map 13.4 二级缓存 二级缓存也叫全局缓存, 一级缓存作用域太低了, 所以诞生了二级缓存基于 namespace 级别的缓存, 一个名称空间, 对应一个二级缓存 ; 工作机制一个会话查询一条数据, 这个数据就会被放在当前会话的一级缓存中 ; 如果当前会话关闭了, 这个会话对应的一级缓存就没了 ; 但是我们想要的是, 会话关闭了, 一级缓存中的数据被保存到二级缓存中 ; 新的会话查询信息, 就可以从二级缓存中获取内容 ; 不同的 mapper 查出的数据会放在自己对应的缓存 (map) 中 ; 步骤 : 1. 开启全局缓存 <!-- 显示的开启全局缓存 --> <setting name="cacheenabled" value="true"/> 2. 在要使用二级缓存的 Mapper 中开启 <!-- 在当前 Mapper.xml 中使用二级缓存 --> <cache/> 也可以自定义参数

27 <!-- 在当前 Mapper.xml 中使用二级缓存 --> <cache eviction="fifo" flushinterval="60000" size="512" readonly="true"/> 3. 测试 1. 问题 : 我们需要将实体类序列化! 否则就会报错! Caused by: java.io.notserializableexception: com.kuang.pojo.user 小结 : 只要开启了二级缓存, 在同一个 Mapper 下就有效所有的数据都会先放在一级缓存中 ; 只有当会话提交, 或者关闭的时候, 才会提交到二级缓冲中! 13.5 缓存原理 13.6 自定义缓存 -ehcache Ehcache 是一种广泛使用的开源 Java 分布式缓存 主要面向通用缓存 要在程序中使用 ehcache, 先要导包!

28 <! > <dependency> <groupid>org.mybatis.caches</groupid> <artifactid>mybatis-ehcache</artifactid> <version>1.1.0</version> </dependency> 在 mapper 中指定使用我们的 ehcache 缓存实现! <!-- 在当前 Mapper.xml 中使用二级缓存 --> <cache type="org.mybatis.caches.ehcache.ehcachecache"/> ehcache.xml <?xml version="1.0" encoding="utf-8"?> <ehcache xmlns:xsi=" xsi:nonamespaceschemalocation=" updatecheck="false"> <!-- diskstore: 为缓存路径,ehcache 分为内存和磁盘两级, 此属性定义磁盘的缓存位置 参数解释如下 : user.home 用户主目录 user.dir 用户当前工作目录 java.io.tmpdir 默认临时文件路径 --> <diskstore path="./tmpdir/tmp_ehcache"/> <defaultcache eternal="false" maxelementsinmemory="10000" overflowtodisk="false" diskpersistent="false" timetoidleseconds="1800" timetoliveseconds="259200" memorystoreevictionpolicy="lru"/> <cache name="cloud_user" eternal="false" maxelementsinmemory="5000" overflowtodisk="false" diskpersistent="false" timetoidleseconds="1800" timetoliveseconds="1800" memorystoreevictionpolicy="lru"/> <!-- defaultcache: 默认缓存策略, 当 ehcache 找不到定义的缓存时, 则使用这个缓存策略 只能定义一个 --> <!-- name: 缓存名称 maxelementsinmemory: 缓存最大数目 maxelementsondisk: 硬盘最大缓存个数 eternal: 对象是否永久有效, 一但设置了,timeout 将不起作用

29 overflowtodisk: 是否保存到磁盘, 当系统当机时 timetoidleseconds: 设置对象在失效前的允许闲置时间 ( 单位 : 秒 ) 仅当 eternal=false 对象不是永久有效时使用, 可选属性, 默认值是 0, 也就是可闲置时间无穷大 timetoliveseconds: 设置对象在失效前允许存活时间 ( 单位 : 秒 ) 最大时间介于创建时间和失效时间之间 仅当 eternal=false 对象不是永久有效时使用, 默认是 0., 也就是对象存活时间无穷大 diskpersistent: 是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false. diskspoolbuffersizemb: 这个参数设置 DiskStore( 磁盘缓存 ) 的缓存区大小 默认是 30MB 每个 Cache 都应该有自己的一个缓冲区 diskexpirythreadintervalseconds: 磁盘失效线程运行时间间隔, 默认是 120 秒 memorystoreevictionpolicy: 当达到 maxelementsinmemory 限制时,Ehcache 将会根据指定的策略去清理内存 默认策略是 LRU( 最近最少使用 ) 你可以设置为 FIFO( 先进先出 ) 或是 LFU( 较少使用 ) clearonflush: 内存数量最大时是否清除 memorystoreevictionpolicy: 可选策略有 :LRU( 最近最少使用, 默认策略 ) FIFO( 先进先出 ) LFU( 最少访问次数 ) FIFO,first in first out, 这个是大家最熟的, 先进先出 LFU, Less Frequently Used, 就是上面例子中使用的策略, 直白一点就是讲一直以来最少被使用的 如上面所讲, 缓存的元素有一个 hit 属性,hit 值最小的将会被清出缓存 LRU,Least Recently Used, 最近最少使用的, 缓存的元素有一个时间戳, 当缓存容量满了, 而又需要腾出地方来缓存新的元素的时候, 那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存 --> </ehcache> Redis 数据库来做缓存! K-V 1. Spring 1.1 简介 Spring : 春天 2002 年, 首次推出 Spring 框架的雏形 : interface21 框架 <! > <dependency> <groupid>org.springframework</groupid> <artifactid>spring-webmvc</artifactid> <version> release</version> </dependency> <! > <dependency> <groupid>org.springframework</groupid> <artifactid>spring-jdbc</artifactid> <version> release</version> </dependency> 1.2 优点 Spring 是一个开源的免费的容器 ( 框架 ) Spring 是一个轻量级的, 非入侵式的框架控制反转 (IOC), 面向切面 (AOP)

30 支持事务的处理, 对框架整合的支持 总结一句话 : Spring 是一个轻量级的控制反转 (IOC) 和面向切面编程 (AOP) 的框架 1.3 组成 组成 Spring 框架的每个模块 ( 或者组件 ) 都可以单独存在, 或者与其他一个或多个模块联合实现 每个模块的功能如下 : 核心容器 : 核心容器提供 Spring 框架的基本功能 核心容器的主要组件是 BeanFactory, 它是工厂模式的实现 BeanFactory 使用控制反转 (IOC) 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开 Spring 上下文 :Spring 上下文是一个配置文件, 向 Spring 框架提供上下文信息 Spring 上下文包括企业服务, 例如 JNDI EJB 电子邮件 国际化 校验和调度功能 Spring AOP: 通过配置管理特性,Spring AOP 模块直接将面向切面的编程功能, 集成到了 Spring 框架中 所以, 可以很容易地使 Spring 框架管理任何支持 AOP 的对象 Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务 通过使用 Spring AOP, 不用依赖组件, 就可以将声明性事务管理集成到应用程序中 Spring DAO:JDBC DAO 抽象层提供了有意义的异常层次结构, 可用该结构来管理异常处理和不同数据库供应商抛出的错误消息 异常层次结构简化了错误处理, 并且极大地降低了需要编写的异常代码数量 ( 例如打开和关闭连接 ) Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构 Spring ORM:Spring 框架插入了若干个 ORM 框架, 从而提供了 ORM 的对象关系工具, 其中包括 JDO Hibernate 和 ibatis SQL Map 所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构 Spring Web 模块 :Web 上下文模块建立在应用程序上下文模块之上, 为基于 Web 的应用程序提供了上下文 所以,Spring 框架支持与 Jakarta Struts 的集成 Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作 Spring MVC 框架 :MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现 通过策略接口,MVC 框架变成为高度可配置的,MVC 容纳了大量视图技术, 其中包括 JSP Velocity Tiles itext 和 POI 1.4 扩展

31 Spring Boot 是 Spring 的一套快速配置脚手架, 可以基于 Spring Boot 快速开发单个微服务 ; Spring Cloud 是基于 Spring Boot 实现的 ; Spring Boot 专注于快速 方便集成的单个微服务个体,Spring Cloud 关注全局的服务治理框架 ; Spring Boot 使用了约束优于配置的理念, 很多集成方案已经帮你选择好了, 能不配置就不配置, Spring Cloud 很大的一部分是基于 Spring Boot 来实现,Spring Boot 可以离开 Spring Cloud 独立使用开发项目, 但是 Spring Cloud 离不开 Spring Boot, 属于依赖的关系 SpringBoot 在 SpringClound 中起到了承上启下的作用, 如果你要学习 SpringCloud 必须要学习 SpringBoot 2. IOC 理论推导 新建一个空白的 maven 项目 我们用我们原先的方式写一段代码 : 1. 先写一个 UserDao 接口 public interface UserDao{ public void getuser(); 2. 再去写 Dao 的实现类 public class UserDaoImpl implements public void getuser(){ syso(" 获取用户数据!"); 3 然后去写 UserService 的接口 public interface UserService { public void getuser(); 4 最后写 Service 的实现类

32 public class UserServiceImpl implements UserService { private UserDao userdao = new public void getuser() { userdao.getuser(); 5 public void test(){ UserService service = new UserServiceImpl(); service.getuser(); 这是我们原来的方式, 开始大家也都是这么去写的对吧. 那我们现在修改一下. 把 Userdao 的实现类增加一个. public class UserDaoMySqlImpl implements UserDao public void getuser() { System.out.println("MySql 获取用户数据 "); 紧接着我们要去使用 MySql 的话, 我们就需要去 service 实现类里面修改对应的实现 public class UserServiceImpl implements UserService { private UserDao userdao = new public void getuser() { userdao.getuser(); 在假设, 我们再增加一个 Userdao 的实现类. public class UserDaoOracleImpl implements UserDao public void getuser() { System.out.println("Oracle 获取用户数据 "); 那么我们要使用 Oracle, 又需要去 service 实现类里面修改对应的实现. 假设我们的这种需求非常大, 这种方式就根本不适用了, 甚至反人类对吧, 每次变动, 都需要修改大量代码. 这种设计的耦合性太高了, 牵一发而动全身. 那我们如何去解决呢? 我们可以在需要用到他的地方, 不去实现它, 而是留出一个接口, 利用 set, 我们去代码里修改下.

33 public class UserServiceImpl implements UserService { private UserDao userdao; // 利用 set 实现 public void setuserdao(userdao userdao) { this.userdao = public void getuser() { userdao.getuser(); 现在去我们的测试类里, 进行测试 public void test(){ UserServiceImpl service = new UserServiceImpl(); service.setuserdao( new UserDaoMySqlImpl() ); service.getuser(); // 那我们现在又想用 Oracle 去实现呢 service.setuserdao( new UserDaoOracleImpl() ); service.getuser(); 大家发现了区别没有? 可能很多人说没啥区别. 但是同学们, 他们已经发生了根本性的变化, 很多地方都不一样了. 仔细去思考一下, 以前所有东西都是由程序去进行控制创建, 而现在是由我们自行控制创建对象, 把主动权交给了调用者. 程序不用去管怎么创建, 怎么实现了. 它只负责提供一个接口. 这种思想, 从本质上解决了问题, 我们程序员不再去管理对象的创建了, 更多的去关注业务的实现. 耦合性大大降低. 这也就是 IOC 的原型! 在我们之前的业务中, 用户的需求可能会影响我们的原来代码, 我们需要根据用户的需求去修改源代码, 如果程序代码量十分大, 修改一次的成本代价十分昂贵我们使用一个 Set 接口实现, 已经发生了革命性的变化 // 利用 set 进行动态实现值的注入 public void setuserdao(userdao userdao){ this.userdao = userdao; 之前, 程序是主动创建对象, 控制权在程序员手里使用了 set 注入后, 程序不在具有主动性, 而是变成了被动的接受对象这种思想, 从本质上解决了问题, 我们程序员不用再去管理对象的创建 系统的耦合性大大降低, 可以更加专注的在业务的实现上! 这是 IOC 的原型! 3. IOC 本质 控制反转 IoC(Inversion of Control), 是一种设计思想,DI( 依赖注入 ) 是 IoC 的一种实现方法, 也有人认为 DI 只是 IoC 的另一种说法 没有 IoC 的程序中, 我们使用面向对象编程, 对象的创建与对象间的依赖关系完全硬编码在程序中, 对象的创建由程序自己控制, 控制反转后将对象的创建转移给第三方, 个人认为所谓控制反转就是 : 获得依赖对象的方式反转了

34 IoC 是 Spring 框架的核心内容, 使用多种方式完美的实现了 IoC, 可以使用 XML 配置, 也可以使用注解, 新版本的 Spring 也可以零配置实现 IoC Spring 容器在初始化时先读取配置文件, 根据配置文件或元数据创建与组织对象存入容器中, 程序使用时再从 Ioc 容器中取出需要的对象 采用 XML 方式配置 Bean 的时候,Bean 的定义信息是和实现分离的, 而采用注解的方式可以把两者合为一体,Bean 的定义信息直接以注解的形式定义在实现类中, 从而达到了零配置的目的 控制反转是一种通过描述 (XML 或注解 ) 并通过第三方去生产或获取特定对象的方式 在 Spring 中实现控制反转的是 IoC 容器, 其实现方法是依赖注入 (Dependency Injection,DI) 4. Hello Spring 1. 导入 jar 包 ( 使用 maven, 文章一开始有教程 ) 2. 编写一个 Hello 实体类 public class Hello { private String name; public String getname() { return name; public void setname(string name) { this.name = name; public void show(){ System.out.println("Hello,"+ name ); 3. 编写我们的 Spring 文件, 我们命名未 beans.xml( 为了方便, 官方名字叫 ApplicationContext.xml)

35 <?xml version="1.0" encoding="utf-8"?> <beans xmlns=" xmlns:xsi=" xsi:schemalocation=" <!--bean 就是 java 对象, 由 Spring 创建和管理 --> <bean id="hello" class="com.dualseason.pojo.hello"> <property name="name" value="spring"/> </bean> </beans> 4. public void test(){ // 解析 beans.xml 文件, 生成管理相应的 Bean 对象 Application context = new ClassPathXmlApplicationContext("beans.xml"); //getbean : 参数即为 Spring 配置文件中 bean 的 id Hello hello = (Hello)context.getBean("hello"); hello.show(); 5. 思考 : Hello 对象是谁创建的? hello 对象是有 Spring 创建的 Hello 对象的属性是怎么设置的? Hello 对象的属性是由 Spring 容器设置的这个过程就叫做控制反转控制 : 谁来控制对象的创建, 传统应用程序的对象是由程序本身控制创建的, 使用 Spring 后, 对象是由 Spring 来创建的反转 : 程序本身不创建对象, 而变成被动的接收对象依赖注入 : 就是利用 set 方法来进行注入的 IOC 是一种编程思想, 由主动的编程变成被动的接收可以通过 new ClassPathXmlApplicationContext 去浏览一下底层代码 //step1 public ClassPathXmlApplicationContext(String configlocation) throws BeansException { this(new String[] {configlocation, true, null); //step2 public ClassPathXmlApplicationContext( String[] configlocations, boolean ApplicationContext parent) throws BeansException { super(parent);

36 setconfiglocations(configlocations); if (refresh) { refresh(); //step3.1 public AbstractXmlApplicationContext(@Nullable ApplicationContext parent) { super(parent); //step3.2 public void setconfiglocations(@nullable String... locations) { if (locations!= null) { Assert.noNullElements(locations, "Config locations must not be null"); this.configlocations = new String[locations.length]; for (int i = 0; i < locations.length; i++) { this.configlocations[i] = resolvepath(locations[i]).trim(); else { this.configlocations = null; public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupshutdownmonitor) { // Prepare this context for refreshing. preparerefresh(); // Tell the subclass to refresh the internal bean factory. ConfigurableListableBeanFactory beanfactory = obtainfreshbeanfactory(); // Prepare the bean factory for use in this context. preparebeanfactory(beanfactory); try { // Allows post-processing of the bean factory in context subclasses. postprocessbeanfactory(beanfactory); // Invoke factory processors registered as beans in the context. invokebeanfactorypostprocessors(beanfactory); // Register bean processors that intercept bean creation. registerbeanpostprocessors(beanfactory); // Initialize message source for this context. initmessagesource(); // Initialize event multicaster for this context. initapplicationeventmulticaster(); // Initialize other special beans in specific context subclasses. onrefresh(); // Check for listener beans and register them. registerlisteners(); // Instantiate all remaining (non-lazy-init) singletons.

37 finishbeanfactoryinitialization(beanfactory); // Last step: publish corresponding event. finishrefresh(); - " + catch (BeansException ex) { if (logger.iswarnenabled()) { logger.warn("exception encountered during context initialization "cancelling refresh attempt: " + ex); // Destroy already created singletons to avoid dangling resources. destroybeans(); // Reset 'active' flag. cancelrefresh(ex); // Propagate exception to caller. throw ex; finally { // Reset common introspection caches in Spring's core, since we // might not ever need metadata for singleton beans anymore... resetcommoncaches(); 6. 修改案例 我们在上面一开始的的案例中, 新增一个 Spring 配置文件 beans.xml <?xml version="1.0" encoding="utf-8"?> <beans xmlns=" xmlns:xsi=" xsi:schemalocation=" <bean id="mysqlimpl" class="com.dualseason.dao.impl.userdaomysqlimpl"/> <bean id="oracleimpl" class="com.dualseason.dao.impl.userdaooracleimpl"/> <bean id="serviceimpl" class="com.dualseason.service.impl.userserviceimpl"> <!-- 注意 : 这里的 name 并不是属性, 而是 set 方法后面的那部分, 首字母小写 --> <!-- 引用另外一个 bean, 不是用 value 而是用 ref--> <property name="userdao" ref="oracleimpl"/> </bean> </beans> 测试

38 @Test public void test2(){ ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); UserServiceImpl serviceimpl = (UserServiceImpl) context.getbean("serviceimpl"); serviceimpl.getuser(); 对象由 Spring 来创建, 管理, 装配! 5.IOC 创建对象方式 1. 通过无参构造方法来创建 User.java public class User{ private String name; public User(){ syso("user 无参构造方法 "); public void setname(string name){ this.name = name; public void show(){ syso("name" + name); beans.xml <?xml version="1.0" encoding="utf-8"?> <beans xmlns=" xmlns:xsi=" xsi:schemalocation=" <bean id="user" class="com.dualseason.pojo.user"> </bean> <property name="name" value=" 世杰 "/> </beans> 测试

39 @Test public void test(){ ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); // 在执行 getbean 的时候, user 已经创建好了, 通过无参构造 User user = (User) context.getbean("user"); // 调用对象的方法. user.show(); 结果可以发现, 在调用 show 方法之前,User 对象已经通过无参构造初始化了 2. 通过有参构造方法来创建 UserT.java public class UserT { private String name; public UserT(String name) { this.name = name; public void setname(string name) { this.name = name; public void show(){ System.out.println("name="+ name ); beans.xml 有三种方式编写 <!-- 第一种根据 index 参数下标设置 --> <bean id="usert" class="com.dualseason.pojo.usert"> <!--index 指构造方法, 下标从 0 开始 --> <constructor-arg index="0" value=" 世杰 "/> </bean> <!-- 第二种根据参数名字设置 --> <bean id="usert" class="com.dualseason.pojo.usert"> <!--name 指参数名 --> <constructor-arg name="name" value=" 世杰 "/> </bean> <!-- 第三种根据参数类型设置 --> <bean id="usert" class="com.dualseason.pojo.usert"> <constructor-arg type="java.lang.string" value=" 世杰 "/> </bean> 测试

40 @Test public void testt(){ ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); UserT user = (UserT) context.getbean("usert"); user.show(); 结论 : 在配置文件加载的时候 其中管理的对象都已经初始化了! 6.Spring 配置 1. 别名 alias 设置别名, 为 bean 设置别名, 可以设置多个别名 <!-- 设置别名 : 在获取 Bean 的时候可以使用别名获取 --> <alias name="usert" alias="usernew"/> 2. bean 的配置 <!--bean 就是 Java 对象, 由 Spring 创建和管理 --> <!-- id 是 bean 的标识符, 要唯一, 如果没有配置 id,name 就是默认标识符如果配置 id, 又配置了 name, 那么 name 就是别名 name 可以设置多个别名, 可以用逗号, 分号, 空格隔开如果不配置 id 和 name, 可以根据 applicationcontext.getbean(.class) 获取对象 ; class 是 bean 的全限定名 = 包名 + 类名 --> <bean id="hello" name="helloalias" class="com.dualseason.pojo.hello"> <property name="name" value=" 世杰 "/> </bean> 3. import <import resource="{path/beans.xml"/> 7. 依赖注入 Dependency Injection 1. 概念依赖注入 (Dependency Injection) 依赖 : 指 Bean 对象的创建依赖于容器,bean 对象的依赖资源注入 : 指 Bean 对象所依赖的资源, 由容器来设置和装配 2. 构造器注入 ( 上面已经有了, 略 ) 3. Set 注入要求被注入的属性, 必须有 set 方法,set 方法的方法名由 set+ 属性首字母大写, 如果属性是 boolean 类型, 没有 set 方法, 是 is

41 测试 pojo 类 Address.java public class Address { private String address; public String getaddress() { return address; public void setaddress(string address) { this.address = address; Student.java package com.dualseason.pojo; import java.util.list; import java.util.map; import java.util.properties; import java.util.set; public class Student { private String name; private Address address; private String[] books; private List<String> hobbys; private Map<String,String> card; private Set<String> games; private String wife; private Properties info; public void setname(string name) { this.name = name; public void setaddress(address address) { this.address = address; public void setbooks(string[] books) { this.books = books; public void sethobbys(list<string> hobbys) { this.hobbys = hobbys; public void setcard(map<string, String> card) { this.card = card; public void setgames(set<string> games) { this.games = games; public void setwife(string wife) {

42 this.wife = wife; public void setinfo(properties info) { this.info = info; public void show(){ System.out.println("name="+ name + ",address="+ address.getaddress() + ",books=" ); for (String book:books){ System.out.print("<<"+book+">>\t"); System.out.println("\n 爱好 :"+hobbys); System.out.println("card:"+card); System.out.println("games:"+games); System.out.println("wife:"+wife); System.out.println("info:"+info); (1) 常量注入 <bean id="student" class="com.dualseason.pojo.student"> </bean> <property name="name" value=" 世杰 "/> 测试 public void test(){ ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); Student student = (Student) context.getbean("student"); System.out.println(student.getName()); (2) Bean 注入 注意点 : 这里的值是一个引用, ref <bean id="address" class="com.dualseason.pojo.address"> <property name="address" value=" 湛江 "/> </bean> <bean id="student" class="com.dualseason.pojo.student"> <property name="name" value=" 世杰 "/> <property name="address" ref="address"/> </bean> (3) 数组注入

43 <bean id="student" class="com.dualseason.pojo.student"> <property name="name" value=" 世杰 "/> <property name="address" ref="address"> <property name="books"> <array> <value> 西游记 </value> <value> 红楼梦 </value> <value> 水浒传 </value> </array> </property> </bean> (4) List 注入 <property name="hobbys"> <list> <value> 听歌 </value> <value> 看电影 </value> <value> 爬山 </value> </list> </property> (5) Map 注入 <property name="card"> <map> <entry key=" 中国邮政 " value=" "/> <entry key=" 建设 " value=" "/> </map> </property> (6) set 注入 <property name="games"> <set> <value>lol</value> <value> 原神 </value> <value> 王者荣耀 </value> </set> </property> (7) NULL 注入 <property name="wife"> <null/> </property> (8) Properties 注入

44 <property name="info"> <props> <prop key=" 学号 "> </prop> <prop key=" 性别 "> 男 </prop> <prop key=" 姓名 "> 世杰 </prop> </props> </property> 4. 命名和 c 命名注入 User.java 注意 : 这里没有有参构造器 public class User { private String name; private int age; public void setname(string name) { this.name = name; public void setage(int age) { this.age = public String tostring() { return "User{" + "name='" + name + '\'' + ", age=" + age + ''; (1) p 命名空间注入 : 需要在头文件中加入约束文件 导入约束 : xmlns:p=" <!--p( 属性 :properties) 命名空间, 属性依然要设置 set 方法 --> <bean id="user" class="com.dualseason.pojo" p:name=" 世杰 " p:age="21"/> (2) c 命名空间注入 : 需要在文件中加入约束文件 导入约束 : xmlns:c=" <!--c( 构造 :constructor) 命名空间, 要把有参构造器加上 --> <bean id="user" class="com.dualseason.pojo.user" c:name=" 世杰 " c:age="21"/> 测试代码 :

45 @Test public void test02(){ ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); User user = (User) context.getbean("user"); System.out.println(user); 5. Bean 作用域 在 Spring 中, 那些组成应用程序的主体及由 Spring Ioc 容器所管理的对象, 被称为 bean 简单地 讲,bean 就是由 IOC 容器初始化 装配及管理的对象 1. 单例模式 ( 默认 ) <bean id="use2" class="com.pojo.user" c:name=" 世杰 " c:age="19" scope="singleton"> </bean> 2. 原型模式 : 每次从容器中 get 的时候, 都产生一个新对象!

46 <bean id="use2" class="com.pojo.user" c:name=" 世杰 " c:age="19" scope="prototype"> </bean> 3. 其余的 request session application 这些只能在 web 开放中使用! 8. Bean 的自动装配 自动装配是 Spring 的满足 bean 依赖的一种方式 Spring 会在上下文自动寻找, 并自动给 bean 装配属性 <?xml version="1.0" encoding="gbk"?> <beans xmlns=" xmlns:xsi=" xsi:schemalocation=" <bean id="cat" class="com.dualseason.pojo.cat"/> <bean id="dog" class="com.dualseason.pojo.dog"/> <!-- byname: 会自动在容器上下文中查找, 和自己对象 set 方法后面的值对应的 bean id bytype: 会自动在容器上下文中查找, 和自己对象属性类型相同的 bean --> <bean id="people" class="com.dualseason.pojo.people" autowire="byname"> <property name="name" value=" 世杰 "/> </bean> </beans> 使用注解自动装配 导入 context 约束

47 <?xml version="1.0" encoding="utf-8"?> <beans xmlns=" xmlns:xsi=" xmlns:context=" xsi:schemalocation=" <context:annotation-config/> 在属性上使用, 也可以在 set 上使用 public class private Cat private Dog dog; private String 字段标志的注解, 说明这个字段可以为 null 自动装配环境比较复杂, 自动装配无法通过一个注解完成的时候 去配合使用, 指定一个唯一的 id 对象 public class private private Dog dog; private String 注解 public class private Cat private Dog dog; 小结 的区别 :

48 @Autowired 通过 bytype 实现, 默认通过 byname 实现, 如果找不到, 通过 bytype 实现执行顺序不同 通过 bytype 默认通过 byname 实现 9. 使用注解开发 在 Spring4 之后, 必须要保证 aop 的包导入 使用注解需要导入 context 的约束 <?xml version="1.0" encoding="gbk"?> <beans xmlns=" xmlns:xsi=" xmlns:context=" xmlns:aop=" xsi:schemalocation=" </beans> <context:annotation-config/> 1. 属性如何注入 // 等价于 <bean id="user" public class User{ public String name; // 相当于 //<property name="name" value=" 世杰 世杰 ") public void setname(string name){ this.name = name; 2. 有几个衍生注解, 会按照 Web 开发中,MVC 架构分层 dao(@repository) pojo (@Component) service (@Service) controller (@Controller) 这四个注解功能都是一样的, 都是代表将某个类注册到容器中 3. 作用域

49 @Scope("singleton") public class 世杰 ") private String name; public String getname(){ return name; public void setname(string name){ this.name = name; 小结 : xml 与注解 xml 更加万能, 维护简单注解, 不是自己的类, 使用不了, 维护复杂最佳实践 xml 用来管理 bean 注解只用来完成属性的注入 <?xml version="1.0" encoding="gbk"?> <beans xmlns=" xmlns:xsi=" xmlns:context=" xmlns:aop=" xsi:schemalocation=" <context:annotation-config/> <!-- 指定要扫描的包 --> <context:component-scan base-package="com.pojo"/> </beans> 10. 使用 java 方式配置 Spring JavaConfig Spring 的一个子项目, 在 Spring4 之后, 他成了核心功能

50 @Configuration // 这个也会被 spring 容器托管, @Import(Config.class) public class public User getuser(){ return new public class User 世杰 ") private String name; public String getname() { return name; public void setname(string name) { this.name = public String tostring() { return "User{" + "name='" + name + '\'' + ''; 这种纯 Java 配置方式 在 SpringBoot 中, 随处可见 10. 动态代理 动态代理和静态代理角色一样动态代理类是动态生成的, 不是我们直接写好的! 动态代理 : 基于接口, 基于类基于接口 :JDK 的动态代理 使用 基于类 :cglib java 字节码 InvocationHandler Proxy

51 import java.lang.reflect.invocationhandler; import java.lang.reflect.method; import java.lang.reflect.proxy; // 会这个类, 自动生成代理类 public class ProxyInvocation implements InvocationHandler { // 被代理的接口 private Rent rent; public void setrent(rent rent) { this.rent = rent; // 生成代理类 public Object getproxy(){ return Proxy.newProxyInstance (this.getclass().getclassloader(),rent.getclass().getinterfaces(),this); // 处理代理实例, 并返回结果 public Object invoke(object proxy, Method method, Object[] args) throws Throwable { seehouse(); Object result = method.invoke(rent, args); fare(); return result; public void seehouse(){ System.out.println("see house"); public void fare(){ System.out.println("fare"); public interface Rent { void rent(); public class Host implements Rent { public void rent() { System.out.println("host rent"); public class Client { public static void main(string[] args) { // 真实角色 Host host = new Host(); // 代理角色 ProxyInvocation proxyinvocation = new ProxyInvocation(); // 通过调用程序处理角色来处理我们要调用的接口对象 proxyinvocation.setrent(host);

52 Rent proxy = (Rent) proxyinvocation.getproxy(); // 这里的 proxy 是动态生成的 proxy.rent(); 11.AOP <dependencies> <dependency> <groupid>org.aspectj</groupid> <artifactid>aspectjweaver</artifactid> <version>1.9.4</version> </dependency> </dependencies> 方法一 : 使用 Spring 接口 SpringAPI 接口实现 <?xml version="1.0" encoding="gbk"?> <beans xmlns=" xmlns:xsi=" xmlns:context=" xmlns:aop=" xsi:schemalocation=" <!-- 注册 bean--> <bean id="userservice" class="com.dualseason.service.userserviceimpl"/> <bean id="afterlog" class="com.dualseason.log.afterlog"/> <bean id="log" class="com.dualseason.log.log"/> <!-- 方式一 : 使用原生 Spring API 接口 --> <!-- 配置 aop--> <aop:config> <!-- 切入点 :expression: 表达式,execution--> <!--UserServiceImpl 任意方法执行 --> <aop:pointcut id="pointcut" expression="execution(* com.dualseason.service.userserviceimpl.*(..))"/> <!-- 执行环绕增强 --> <aop:advisor advice-ref="log" pointcut-ref="pointcut"/> <aop:advisor advice-ref="afterlog" pointcut-ref="pointcut"/> </aop:config> </beans> public class UserServiceImp implements UserService {

53 public void add() { System.out.println("add"); public void delete() { System.out.println("delete"); public void query() { System.out.println("query"); public void update() { System.out.println("update"); package com.dualseason.log; import org.springframework.aop.methodbeforeadvice; import java.lang.reflect.method; public class Log implements MethodBeforeAdvice { //method: 要执行的目标对象的方法 //args: 参数 //target: 目标对象 public void before(method method, Object[] objects, Object target) throws Throwable { System.out.println(target.getClass().getName() + " 的 " + method.getname() + " 被执行了!"); package com.dualseason.log; import org.springframework.aop.afterreturningadvice; import java.lang.reflect.method; public class AfterLog implements AfterReturningAdvice { //returnvalue 返回值 public void afterreturning(object returnvalue, Method method, Object[] args, Object target) throws Throwable { System.out.println(" 执行了 " + method.getname() + " 方法, 返回结果为 :" + returnvalue);

54 import com.dualseason.service.userservice; import com.dualseason.service.userserviceimpl; import org.junit.test; import org.springframework.context.applicationcontext; import org.springframework.context.support.classpathxmlapplicationcontext; public class MyTest public void test(){ ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); // 动态代理代理的是接口 UserService userservice = (UserService) context.getbean("userservice"); userservice.add(); 方法二 : 自定义来实现 AOP 主要是切面定义 <?xml version="1.0" encoding="gbk"?> <beans xmlns=" xmlns:xsi=" xmlns:context=" xmlns:aop=" xsi:schemalocation=" <!-- 注册 bean--> <bean id="userservice" class="com.dualseason.service.userserviceimpl"/> <bean id="afterlog" class="com.dualseason.log.afterlog"/> <bean id="log" class="com.dualseason.log.log"/> <!-- 方式二 : 自定义类 --> <bean id="diy" class="com.dualseason.diy.diypointcut"/> <aop:config> <aop:aspect ref="diy"> <!-- 切入点 --> <!--UserServiceImpl 接口的任意方法的执行 :--> <aop:pointcut id="point" expression="execution(* com.dualseason.service.userserviceimpl.*(..))"/> <!-- 通知 --> <aop:before method="before" pointcut-ref="point"/> <aop:after method="after" pointcut-ref="point"/> </aop:aspect> </aop:config> </beans> 方法三 : 注解方式

55 <?xml version="1.0" encoding="gbk"?> <beans xmlns=" xmlns:xsi=" xmlns:context=" xmlns:aop=" xsi:schemalocation=" <!-- 注册 bean--> <bean id="userservice" class="com.dualseason.service.userserviceimpl"/> <bean id="afterlog" class="com.dualseason.log.afterlog"/> <bean id="log" class="com.dualseason.log.log"/> <!-- 方式三 --> <bean id="annotationpointcut" class="com.dualseason.diy.annotationpoint"/> <!-- 开启注解支持 JDK( 默认 proxy-target-class="false") cglib(proxy-target-class="true") --> <aop:aspectj-autoproxy/> </beans> package com.dualseason.diy; import org.aspectj.lang.proceedingjoinpoint; import org.aspectj.lang.signature; import org.aspectj.lang.annotation.after; import org.aspectj.lang.annotation.around; import org.aspectj.lang.annotation.aspect; import org.aspectj.lang.annotation.before; // 使用注解方式实现 // 标注这个类是一个切面 public class AnnotationPoint com.dualseason.service.userserviceimpl.*(..))") public void before(){ System.out.println("==== 方法执行前 com.dualseason.service.userserviceimpl.*(..))") public void after(){ System.out.println("==== 方法执行后 ===="); // 在环绕增强中, 我们可以给定一个参数, com.dualseason.service.userserviceimpl.*(..))") public void around(proceedingjoinpoint joinpoint) throws Throwable { System.out.println(" 环绕前 "); Signature signature = joinpoint.getsignature();// 获得签名 System.out.println("signature:" + signature); // 执行方法 Object proceed = joinpoint.proceed();

56 System.out.println(" 环绕后 "); System.out.println(proceed); import com.dualseason.service.userservice; import com.dualseason.service.userserviceimpl; import org.junit.test; import org.springframework.context.applicationcontext; import org.springframework.context.support.classpathxmlapplicationcontext; public class MyTest public void test(){ ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); // 动态代理代理的是接口 UserService userservice = (UserService) context.getbean("userservice"); userservice.add(); 12. 整合 Mybatis 文档 : 步骤 : 1. 导入相关 jar 包 junit mybatis mysql 数据库 spring 相关 aop 织入 mybatis-spring [new] 2. 编写配置文件 3. 测试 <dependencies> <!--mysql 驱动 --> <dependency> <groupid>mysql</groupid> <artifactid>mysql-connector-java</artifactid> <version>8.0.12</version> </dependency> <!--mybatis--> <! > <dependency> <groupid>org.mybatis</groupid>

57 > <artifactid>mybatis</artifactid> <version>3.5.2</version> </dependency> <!--junit--> <dependency> <groupid>junit</groupid> <artifactid>junit</artifactid> <version>4.12</version> </dependency> <! > <dependency> <groupid>log4j</groupid> <artifactid>log4j</artifactid> <version>1.2.17</version> </dependency> <! > <dependency> <groupid>org.projectlombok</groupid> <artifactid>lombok</artifactid> <version> </version> </dependency> <!--Spring 操作数据库的话, 还需要一个 spring-jdbc--> <dependency> <groupid>org.springframework</groupid> <artifactid>spring-jdbc</artifactid> <version>5.0.5.release</version> </dependency> <!-- 织入包 --> <dependency> <groupid>org.aspectj</groupid> <artifactid>aspectjweaver</artifactid> <version>1.8.13</version> </dependency> <dependency> <groupid>org.mybatis</groupid> <artifactid>mybatis-spring</artifactid> <version>2.0.2</version> </dependency> <! <dependency> <groupid>org.springframework</groupid> <artifactid>spring-webmvc</artifactid> <version>5.2.5.release</version> </dependency> <dependency> <groupid>org.springframework</groupid> <artifactid>spring-jdbc</artifactid> <version>5.2.3.release</version> </dependency> </dependencies> <!-- 在 build 中配置 resources, 来防止我们资源导出失败的问题 --> <build> <resources> <resource> <directory>src/main/resources</directory>

58 <includes> <include>**/*.properties</include> <include>**/*.xml</include> </includes> <filtering>true</filtering> </resource> <resource> <directory>src/main/java</directory> <includes> <include>**/*.properties</include> <include>**/*.xml</include> </includes> <filtering>true</filtering> </resource> </resources> </build> <?xml version="1.0" encoding="gbk"?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//dtd Config 3.0//EN" " <configuration> <properties resource="db.properties"> </properties> <settings> <setting name="logimpl" value="log4j"/> </settings> <typealiases> <package name="com.dualseason.pojo"/> </typealiases> <environments default="development"> <environment id="development"> <transactionmanager type="jdbc"/> <datasource type="pooled"> <property name="driver" value="${driver"/> <property name="url" value="${url"/> <property name="username" value="${username"/> <property name="password" value="${password"/> </datasource> </environment> </environments> <mappers> <mapper class="com.dualseason.mapper.usermapper"/> </mappers> </configuration> driver=com.mysql.cj.jdbc.driver url=jdbc:mysql://localhost:3306/mybatis? servertimezone=gmt%2b8&usessl=false&useunicode=true&characterencoding=utf-8 username=root password= 密码

59 <?xml version="1.0" encoding="gbk"?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//dtd Config 3.0//EN" " <mapper namespace="com.dualseason.mapper.usermapper"> <select id="selectuser" resulttype="user"> select * from mybatis.user </select> </mapper> package com.dualseason.pojo; import public class User { private int id; private String name; private String pwd; package com.dualseason.mapper; import com.dualseason.pojo.user; import java.util.list; public interface UserMapper { public List<User> selectuser(); package com.dualseason.utils; import org.apache.ibatis.io.resources; import org.apache.ibatis.session.sqlsession; import org.apache.ibatis.session.sqlsessionfactory; import org.apache.ibatis.session.sqlsessionfactorybuilder; import java.io.ioexception; import java.io.inputstream; //sqlsessionfactory --> sqlsession public class MybatisUtils { private static SqlSessionFactory sqlsessionfactory; static{ try { // 使用 Mybatis 第一步 // 获取 sqlsessionfactory 对象 String resource = "mybatis-config.xml";

60 InputStream inputstream = Resources.getResourceAsStream(resource); sqlsessionfactory = new SqlSessionFactoryBuilder().build(inputStream); catch (IOException e) { e.printstacktrace(); // 既然有了 SqlSessionFactory, 顾名思义, 我们就可以从中获取 SqlSession 的实例了 //SqlSession 完全包含了面向数据库执行 SQL 命令所需的方法 public static SqlSession getsqlsession(){ return sqlsessionfactory.opensession(); # 将等级为 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/dualseason.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 整合 方法一 :SqlSessionTemplate mapper 包 package com.dualseason.mapper; import com.dualseason.pojo.user; import org.mybatis.spring.sqlsessiontemplate; import java.util.list; public class UserMapperImpl implements UserMapper { // 我们的所有操作都使用 sqlsession 来执行

61 // 在原来, 现在都在使用 SqlSessionTemplate private SqlSessionTemplate sqlsession; public void setsqlsession(sqlsessiontemplate sqlsession) { this.sqlsession = sqlsession; public List<User> selectuser() { UserMapper mapper = sqlsession.getmapper(usermapper.class); return mapper.selectuser(); package com.dualseason.mapper; import com.dualseason.pojo.user; import java.util.list; public interface UserMapper { public List<User> selectuser(); <?xml version="1.0" encoding="gbk"?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//dtd Config 3.0//EN" " <mapper namespace="com.dualseason.mapper.usermapper"> <select id="selectuser" resulttype="user"> select * from mybatis.user </select> </mapper> pojo 包 package com.dualseason.pojo; import public class User { private int id; private String name; private String pwd; resource 包

62 mybatis-config.xml <?xml version="1.0" encoding="gbk"?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//dtd Config 3.0//EN" " <configuration> <settings> <setting name="logimpl" value="log4j"/> </settings> <typealiases> <package name="com.dualseason.pojo"/> </typealiases> </configuration> spring-dao.xml <?xml version="1.0" encoding="gbk"?> <beans xmlns=" xmlns:xsi=" xmlns:context=" xmlns:aop=" xsi:schemalocation=" <!--DataSource: 使用 Spring 的数据源替换 Mybatis 的配置 --> <bean id="datasource" class="org.springframework.jdbc.datasource.drivermanagerdatasource"> <property name="driverclassname" value="com.mysql.cj.jdbc.driver"/> <property name="url" value="jdbc:mysql://localhost:3306/mybatis? servertimezone=gmt%2b8&usessl=false&useunicode=true&characterencodin g=utf-8"/> <property name="username" value="root"/> <property name="password" value=" 密码 "/> </bean> <!--sqlsessionfactory: 代替的是 MybatisUtils 类 --> <bean id="sqlsessionfactory" class="org.mybatis.spring.sqlsessionfactorybean"> <property name="datasource" ref="datasource" /> <!-- 绑定 Mybatis 配置文件 --> <property name="configlocation" value="classpath:mybatis-config.xml"/> <property name="mapperlocations" value="classpath:com/dualseason/mapper/usermapper.xml"/> </bean> <!--SqlSessionTemplate: 就是我们使用的 sqlsession--> <bean id="sqlsession" class="org.mybatis.spring.sqlsessiontemplate"> <!-- 只能使用构造器注入 sqlsessionfactory, 因为它没有 set 方法 --> <constructor-arg index="0" ref="sqlsessionfactory"/> </bean>

63 <!-- 注入实现类 --> <bean id="usermapper" class="com.dualseason.mapper.usermapperimpl"> <property name="sqlsession" ref="sqlsession"/> </bean> </beans> applicationcontext.xml <?xml version="1.0" encoding="gbk"?> <beans xmlns=" xmlns:xsi=" xmlns:context=" xmlns:aop=" xsi:schemalocation=" <import resource="spring-dao.xml"/> <!-- 注入实现类 --> <bean id="usermapper" class="com.dualseason.mapper.usermapperimpl"> <property name="sqlsession" ref="sqlsession"/> </bean> </beans> test import com.dualseason.mapper.usermapper; import com.dualseason.pojo.user; import com.dualseason.utils.mybatisutils; import org.apache.ibatis.session.sqlsession; import org.junit.test; import org.springframework.context.applicationcontext; import org.springframework.context.support.classpathxmlapplicationcontext; import java.util.list; public class MyTest public void test(){ ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); UserMapper usermapper = context.getbean("usermapper", UserMapper.class); List<User> users = usermapper.selectuser(); for (User user : users) { System.out.println(user);

64 1. 编写数据源配置 2. sqlsessionfactory 3. sqlsessiontemplate 4. 需要给接口加实现类 5. 将自己写的实现类注入到 Spring 中, 测试方法二 :SqlSessionDaoSupport <!-- 注入实现类 --> <bean id="usermapper2" class="com.dualseason.mapper.usermapperimpl2"> <property name="sqlsessionfactory" ref="sqlsessionfactory"/> </bean> package com.dualseason.mapper; import com.dualseason.pojo.user; import org.apache.ibatis.session.sqlsession; import org.mybatis.spring.sqlsessiontemplate; import org.mybatis.spring.support.sqlsessiondaosupport; import java.util.list; public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper { public List<User> selectuser() { return public void test3(){ ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); UserMapper usermapper = context.getbean("usermapper2", UserMapper.class); List<User> users = usermapper.selectuser(); for (User user : users) { System.out.println(user); 13. 声明式事务 要么都成功, 要么都失败十分重要, 涉及到数据一致性确保完整性和一致性事务的 ACID 原则 :

65 原子性 一致性 隔离性 持久性 多个业务可能操作一个资源, 防止数据损坏 事务一旦提交, 无论系统发生什么问题, 结果都不会被影响 被持久化写到存储器中 Spring 中的事务管理声明式事务编程式事务声明式事务 spring-dao.xml <?xml version="1.0" encoding="gbk"?> <beans xmlns=" xmlns:xsi=" xmlns:context=" xmlns:aop=" xmlns:tx=" xsi:schemalocation=" <!--DataSource: 使用 Spring 的数据源替换 Mybatis 的配置 --> <bean id="datasource" class="org.springframework.jdbc.datasource.drivermanagerdatasource"> <property name="driverclassname" value="com.mysql.cj.jdbc.driver"/> <property name="url" value="jdbc:mysql://localhost:3306/mybatis? servertimezone=gmt%2b8&usessl=false&useunicode=true&characterencodin g=utf-8"/> <property name="username" value="root"/> <property name="password" value=" 密码 "/> </bean> <!--sqlsessionfactory: 代替的是 MybatisUtils 类 --> <bean id="sqlsessionfactory" class="org.mybatis.spring.sqlsessionfactorybean"> <property name="datasource" ref="datasource" /> <!-- 绑定 Mybatis 配置文件 --> <property name="configlocation" value="classpath:mybatis-config.xml"/> <property name="mapperlocations" value="classpath:com/dualseason/mapper/usermapper.xml"/> </bean> <!--SqlSessionTemplate: 就是我们使用的 sqlsession--> <bean id="sqlsession" class="org.mybatis.spring.sqlsessiontemplate"> <!-- 只能使用构造器注入 sqlsessionfactory, 因为它没有 set 方法 -->

66 </bean> <constructor-arg index="0" ref="sqlsessionfactory"/> <!-- 注入实现类 --> <bean id="usermapper" class="com.dualseason.mapper.usermapperimpl"> <property name="sqlsessionfactory" ref="sqlsessionfactory"/> </bean> <!-- 配置声明式事务 --> <bean id="transactionmanager" class="org.springframework.jdbc.datasource.datasourcetransactionmanager"> <constructor-arg ref="datasource" /> </bean> <!-- 结合 AOP 实现事务的织入 --> <!-- 配置事务通知 --> <tx:advice id="txadvice" transaction-manager="transactionmanager"> <!-- 给那些方法配置事务 --> <!-- 配置事务的传播特性 :new propagation="required" --> <tx:attributes> <tx:method name="add" propagation="required"/> <tx:method name="delete" propagation="required"/> <tx:method name="update" propagation="required"/> <tx:method name="query" read-only="true"/> <tx:method name="*"/> </tx:attributes> </tx:advice> <!-- 配置事务切入 --> <aop:config> <aop:pointcut id="txpointcut" expression="execution(* com.dualseason..mapper.*.*(..))"/> <aop:advisor advice-ref="txadvice" pointcut-ref="txpointcut"/> </aop:config> </beans> applicationcontext.xml <?xml version="1.0" encoding="gbk"?> <beans xmlns=" xmlns:xsi=" xmlns:context=" xmlns:aop=" xsi:schemalocation=" <import resource="spring-dao.xml"/> <!--bean--> <bean id="usermapper" class="com.dualseason.mapper.usermapperimpl">

67 </bean> <property name="sqlsessionfactory" ref="sqlsessionfactory"/> </beans> mybatis-config.xml <?xml version="1.0" encoding="gbk"?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//dtd Config 3.0//EN" " <configuration> <settings> <setting name="logimpl" value="log4j"/> </settings> <typealiases> <package name="com.dualseason.pojo"/> </typealiases> </configuration> User package com.dualseason.pojo; import lombok.allargsconstructor; import lombok.data; @NoArgsConstructor public class User { private int id; private String name; private String pwd; UserMapper package com.dualseason.mapper; import com.dualseason.pojo.user; import java.util.list; public interface UserMapper { public List<User> selectuser(); // 添加一个用户 public int adduser(user user);

68 // 删除一个用户 public int deleteuser(int id); UserMapper.xml <?xml version="1.0" encoding="gbk"?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//dtd Config 3.0//EN" " <mapper namespace="com.dualseason.mapper.usermapper"> <select id="selectuser" resulttype="user"> select * from mybatis.user </select> <insert id="adduser" parametertype="user"> insert into mybatis.user(id,name,pwd) values (#{id,#{name,#{pwd) </insert> <delete id="deleteuser" parametertype="int"> delete from mybatis.user where id = #{id </delete> </mapper> test import com.dualseason.mapper.usermapper; import com.dualseason.pojo.user; import org.junit.test; import org.springframework.context.applicationcontext; import org.springframework.context.support.classpathxmlapplicationcontext; import java.util.list; public class MyTest public void test(){ ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); UserMapper usermapper = context.getbean("usermapper", UserMapper.class); List<User> users = usermapper.selectuser(); for (User user : users) { System.out.println(user);

69 回顾 MVC 回顾 MVC 什么是 MVC? MVC 是模型 (Model) 视图(View) 控制器(Controller) 的简写, 是一种软件设计规范是将业务逻辑 数据 显示分离的方法来组织代码 MVC 主要作用是降低了视图与业务逻辑间的双向耦合 MVC 不是一种设计模式,MVC 是一种架构模式 当然不同的 MVC 存在差异 Model( 模型 ): 数据模型, 提供要展示的数据, 因此包含数据和行为, 可以认为是领域模型或 JavaBean 组件 ( 包含数据和行为 ) 不过现在一般都是分离开来 :Value Object( 数据 Dao) 和服务层 ( 行为 Service) 也就是模型提供了模型数据查询和模型数据的状态更新等功能, 包括数据和业务 View( 视图 ): 负责进行模型的展示, 一般就是我们见到的用户界面, 客户想看到的东西 Controller( 控制器 ): 接收用户请求, 委托给模型进行处理 ( 状态改变 ), 处理完毕后把返回的模型数据返回给视图, 由视图负责展示 也就是说控制器做了个调度员的工作 最经典的 MVC 就是 :JSP+Servlet+bean 的模式 Model1 时代 在 web 早期的开发中, 通常采用的都是 Model Model1 中, 主要分为两层, 视图和模型层

70 Model1 优点 : 架构简单, 比较适合小型项目开发 Model1 缺点 :JSP 职责不单一, 职责过重, 不便于维护 Molde2 时代 Model2 把一个项目分成三部分 : 包括视图 控制 模型 1 用户发请求 2 Servlet 接收请求的数据, 并调用对应的业务逻辑方法 3 业务处理完毕, 返回更新后的数据给 Servlet 4 Servlet 转向到 JSP, 由 JSP 来渲染页面 5 响应给前端更新后的页面职责分析 : Controller: 控制器 1 取得表单数据 2 调用业务逻辑 3 转向指定的页面 Model: 模型 1 业务逻辑 2 保存数据的状态 View 模型 1 显示页面

71 Model2 这样不仅提高了代码的复用率与项目的扩展性, 且大大降低了项目的维护成本 Model1 模式的实现比较简单, 适用于快速开发小规模项目,Model1 中 jsp 页面身兼 View 和 Controller 两种角色, 将控制逻辑和表现逻辑混杂在一起, 从而导致代码的重用性非常低, 增加了应用的扩展性和维护的难度 Model2 消除了 Model1 的缺点 回顾 Servlet 新建一个 Maven 工程当做父工程!pom 依赖! <dependencies> <dependency> <groupid>junit</groupid> <artifactid>junit</artifactid> <version>4.13</version> </dependency> <dependency> <groupid>org.springframework</groupid> <artifactid>spring-webmvc</artifactid> <version>5.3.5</version> </dependency> <dependency> <groupid>javax.servlet</groupid> <artifactid>servlet-api</artifactid> <version>2.5</version> </dependency> <dependency> <groupid>javax.servlet.jsp</groupid> <artifactid>jsp-api</artifactid> <version>2.2</version> </dependency> <dependency> <groupid>javax.servlet.jsp.jstl</groupid> <artifactid>jstl-api</artifactid> <version>1.2</version> </dependency> </dependencies> 2 简历一个 Moudel:SpringMVC-01-Servlet, 添加 web app 的支持 3 导入 jsp 和 servlet 的 jar 包依赖, 如果父级 pox.xml 文件已经导入, 那么子级是可以不导入的 4 编写一个 Servlet 类, 用来处理用户的请求 public class HelloServlet extends protected void dopost(httpservletrequest req, HttpServletResponse resp) throws ServletException, IOException { // 获取参数判断功能 String str = req.getparameter("list"); if (str.equals("add")) { req.getsession().setattribute("msg"," 添加用户 "); else if(str.equals("delete")) { req.getsession().setattribute("msg"," 删除用户 ");

72 // 调用业务逻辑 // 跳转页面 req.getrequestdispatcher("/web- protected void doget(httpservletrequest req, HttpServletResponse resp) throws ServletException, IOException { dopost(req, resp); 5 编写 helloservlet.jsp, 在 WEB-INF 目录下新建一个 jsp 的文件夹, 新建 hello.jsp <%@ page contenttype="text/html;charset=utf-8" language="java" %> <html> <head> <title> 跳转页面 </title> </head> <body> ${sessionscope.msg </body> </html> 6 在 web.xml 中注册 Servlet <?xml version="1.0" encoding="utf-8"?> <web-app xmlns=" xmlns:xsi=" xsi:schemalocation=" version="4.0"> <!-- 配置路径 --> <servlet> <servlet-name>helloservlet</servlet-name> <servlet-class>com.njxh.servlet.helloservlet</servlet-class> </servlet> <!-- 配置映射路径 --> <servlet-mapping> <servlet-name>helloservlet</servlet-name> <url-pattern>/user</url-pattern> </servlet-mapping> </web-app> 7 创建 form 表单数据提交页面

73 page contenttype="text/html;charset=utf-8" language="java" %> <html> <head> <title> 首页 </title> </head> <body> <form action="/user" method="post"> <input type="text" name="list"> <input type="submit" value=" 提交 "> </form> </body> </html> 8 配置 Tomcat 启动测试也可以直接在浏览器输入 servlet 地址传参 什么是 SpringMVC 概述 Spring MVC 是 Spring Framework 的一部分, 是基于 JAVA 实现实现的 MVC 的轻量级 Web 框架查观官方文档 : e/web.html#spring-web 我们为什么学习 Spring MVC 呢? Spring MVC 的特点 1 轻量级 简单易学 2 高效 基于请响应的 MVC 框架 3 与 Spring 兼容性好, 无缝融合 4 约定大于配置 5 功能强大:RESTful 数据验证 格式化 本地化 主题等 6 简洁灵活 Spring 的 web 框架围绕 DispatcherServlet [ 调度 Servlet ] 设计

74 DispatcherServlet 的作用是将请求分发到不同的处理器 从 Spring 2.5 开始, 使用 Java 5 或者以上版本的用户可以采用基于注解形式进行开发, 十分简洁 ; 正因为 SpringMVC 好, 简单, 便捷, 易学, 天生和 Spring 无缝集成 ( 使用 SpringIoC 和 Aop), 使用约定优于配置. 能够进行简单的 junit 测试. 支持 Restful 风格. 异常处理, 本地化, 国际化, 数据验证, 类型转换, 拦截器等等 所以我们要学习最重要的一点还是用的人多, 使用的公司多 中心控制器 Spring 的 web 框架围绕 DispatcherServlet 设计 DispatcherServlet 的作用是将请求分发到不同的处理器 从 Spring 2.5 开始, 使用 Java 5 或者以上版本的用户可以采用基于注解的 controller 声明方式 Spring MVC 框架像许多其他 MVC 框架一样, 以请求为驱动, 围绕一个中心 Servlet 分派请求及提供其他功能,DispatcherServlet 是一个实际的 Servlet ( 它继承自 HttpServlet 基类 ) SpringMVC 的原理如下图所示 : 当发起请求时被前置的控制器拦截到请求, 根据请求参数生成代理请求, 找到请求对应的实际控制器, 控制器处理请求, 创建数据模型, 访问数据库, 将模型响应给中心控制器, 控制器使用模型与视图渲染视图结果, 将结果返回给中心控制器, 再将结果返回给请求者 SpringMVC 的执行原理

75 图为 SpringMVC 的一个较完整的流程图, 实线表示 SpringMVC 框架提供的技术, 不需要开发者实现, 虚线表示需要开发者实现 简要分析执行流程 1. DispatcherServlet 表示前置控制器, 是整个 SpringMVC 的控制中心 用户发出请求, DispatcherServlet 接收请求并拦截请求 我们假设请求的 url 为 : 如上 url 拆分成三部分 : 服务器域名 SpringMVC 部署在服务器上的 web 站点 hello 表示控制器通过分析, 如上 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. 最终视图呈现给用户 在这里先听一遍原理, 不理解没有关系, 我们马上来写一个对应的代码实现大家就明白了, 如果不明白, 那就写 10 遍, 没有笨人, 只有懒人!

76 第一个 Spring MVC 程序 配置版 1. 新建一个 Moudle, springmvc-02-hello, 添加 web 的支持! 2. 确定导入了 SpringMVC 的依赖! 3. 配置 web.xml, 注册 DispatcherServlet <?xml version="1.0" encoding="utf-8"?> <web-app xmlns=" xmlns:xsi=" xsi:schemalocation=" version="4.0"> <!-- 注册 DispatcherServlet --> <servlet> <servlet-name>springmvc</servlet-name> <servletclass>org.springframework.web.servlet.dispatcherservlet</servlet-class> <!-- 关联 Spring MVC 配置文件 --> <init-param> <param-name>contextconfiglocation</param-name> <param-value>classpath:springmvc-servlet.xml</param-value> </init-param> <!-- 启动级别 -1 服务器启动的时候, 这个程序跟着启动 --> <load-on-startup>1</load-on-startup> </servlet> <!--/ 匹配所有的请求 : ( 不包括 jsp)--> <!--/* 匹配所有的请求 :( 包括 jsp) --> <servlet-mapping> <servlet-name>springmvc</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> </web-app> servlet.xml 说明, 这里的名称要求是按照官方来的 4 编写 SpringMVC 的配置文件! 名称 :springmvc-servlet.xml : \[servletname\]- <?xml version="1.0" encoding="utf-8"?> <beans xmlns=" xmlns:xsi=" xsi:schemalocation=" </beans> 5 添加处理映射器

77 <bean class="org.springframework.web.servlet.handler.beannameurlhandlermapping"/> 6 添加处理器适配器 <bean class="org.springframework.web.servlet.mvc.simplecontrollerhandleradapter"/> 7 添加视图解析器 <!-- 视图解析器 :DispatcherServlet 给他的 ModelAndView--> <bean class="org.springframework.web.servlet.view.internalresourceviewresolver" id="internalresourceviewresolver"> <!-- 前缀 --> <property name="prefix" value="/web-inf/jsp/"/> <!-- 后缀 --> <property name="suffix" value=".jsp"/> </bean> 8 编写我们要操作业务 Controller, 要么实现 Controller 接口, 要么增加注解 ; 需要返回一个 ModelAndView, 装数据, 封视图 ; package com.njxh.controller; import org.springframework.web.servlet.modelandview; import org.springframework.web.servlet.mvc.controller; import javax.servlet.http.httpservletrequest; import javax.servlet.http.httpservletresponse; /** HelloController Controller 控制层 dualseason 2021/3/18 19: */ public class HelloController implements Controller public ModelAndView handlerequest(httpservletrequest httpservletrequest, HttpServletResponse httpservletresponse) throws Exception { // 创建 ModelAndView 模型和视图 ModelAndView mv = new ModelAndView(); // 封装对象, 放在 ModelAndView 中 mv.addobject("msg","hellospringmvc"); // 封装要跳转的视图, 放在 ModelAndView 中 mv.setviewname("hello"); return mv;

78 9 将自己的类交给 SpringIOC 容器, 注册 bean <!--Handler--> <bean id="/hello" class="com.kuang.controller.hellocontroller"/> 10 写要跳转的 jsp 页面, 显示 ModelandView 存放的数据, 以及我们的正常页面 ; <%@ page contenttype="text/html;charset=utf-8" language="java" %> <html> <head> <title> 跳转页面 </title> </head> <body> ${msg </body> </html> 11 配置 Tomcat 启动测试! 可能遇到的问题 : 访问出现 404, 排查步骤 : 1. 查看控制台输出, 看一下是不是缺少了什么 jar 包 2. 如果 jar 包存在, 显示无法输出, 就在 IDEA 的项目发布中, 添加 lib 依赖! 3. 重启 Tomcat 即可解决! 小结 : 看这个估计大部分同学都能理解其中的原理了, 但是我们实际开发才不会这么写, 不然就疯了, 还学这个玩意干嘛! 我们来看个注解版实现, 这才是 SpringMVC 的精髓, 到底有多么简单, 看这个图就知道了 注解版 1 新建一个 Moudle springmvc-servlet-03-hello-annotation, 添加 web 支持 2 由于 Maven 可能存在资源过滤的问题, 我们将配置完善 <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>

79 <includes> <include>**/*.properties</include> <include>**/*.xml</include> </includes> <filtering>false</filtering> </resource> </resources> </build> 3 在 pom.xml 文件引入相关的依赖 : 主要有 Spring 框架核心库 Spring MVC servlet, JSTL 等 我们在父依赖中已经引入了! 4 配置 web.xml 注意点 : <?xml version="1.0" encoding="utf-8"?> <web-app xmlns=" xmlns:xsi=" xsi:schemalocation=" version="4.0"> <!--1. 注册 servlet--> <servlet> <servlet-name>springmvc</servlet-name> <servletclass>org.springframework.web.servlet.dispatcherservlet</servlet-class> <!-- 通过初始化参数指定 SpringMVC 配置文件的位置, 进行关联 --> <init-param> <param-name>contextconfiglocation</param-name> <param-value>classpath:springmvc-servlet.xml</param-value> </init-param> <!-- 启动顺序, 数字越小, 启动越早 --> <load-on-startup>1</load-on-startup> </servlet> <!-- 所有请求都会被 springmvc 拦截 --> <servlet-mapping> <servlet-name>springmvc</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> </web-app> / 和 /* 的区别 :< url-pattern > / </ url-pattern > 不会匹配到.jsp, 只针对我们编写的请求 ; 即 :.jsp 不会进入 spring 的 DispatcherServlet 类 < url-pattern > /* </ url-pattern > 会匹配 *.jsp, 会出现返回 jsp 视图时再次进入 spring 的 DispatcherServlet 类, 导致找不到对应的 controller 所以报 404 错 注意 web.xml 版本问题, 要最新版! 注册 DispatcherServlet 关联 SpringMVC 的配置文件启动级别为 1 映射路径为 / 不要用/*, 会 404

80 5 添加 Spring MVC 配置文件 在 resource 目录下添加 springmvc-servlet.xml 配置文件, 配置的形式与 Spring 容器配置基本类似, 为了支持基于注解的 IOC, 设置了自动扫描包的功能, 具体配置信息如下 : <?xml version="1.0" encoding="utf-8"?> <beans xmlns=" xmlns:xsi=" xmlns:context=" xmlns:mvc=" xsi:schemalocation=" <!-- 自动扫描包, 让指定包下的注解生效, 由 IOC 容器同一管理 --> <context:component-scan base-package="com.njxh.controller"/> <!-- 让 SpringMVC 不处理静态资源 --> <mvc:default-servlet-handler/> <!-- 通过注解自动生成, 映射和适配器 --> <!-- 支持 mvc 注解驱动在 spring 注解生效必须向上下文中注册 DefaultAnnotationHandlerMapping 和一个 AnnotationMethodHandlerAdapter 实例这两个实例分别在类级别和方法级别处理 而 annotation-driven 配置帮助我们自动完成上述两个实例的注入 --> <mvc:annotation-driven/> <!-- 定义视图解析器 --> <bean id="internalresourceviewresolver" class="org.springframework.web.servlet.view.internalresourceviewresolver"> <!-- 定义前缀 --> <property name="prefix" value="/web-inf/jsp/"/> <!-- 定义后缀 --> <property name="suffix" value=".jsp"/> </bean> </beans> 在视图解析器中我们把所有的视图都存放在 /WEB-INF/ 目录下, 这样可以保证视图安全, 因为这个目录下的文件, 客户端不能直接访问 让 IOC 的注解生效静态资源过滤 :HTML. JS. CSS. 图片, 视频 MVC 的注解驱动配置视图解析器 6 创建 Controller 编写一个 Java 控制类 :com.kuang.controller.hellocontroller, 注意编码规范 package com.njxh.controller;

81 import org.springframework.stereotype.controller; import org.springframework.ui.model; import org.springframework.web.bind.annotation.requestmapping; /** HelloController 控制层 xiaoding 2021/3/19 9:38 public class HelloController { // 真时项目访问地址 public String hello1(model mv) { // 添加数据 mv.addattribute("msg","hellospringmvcannotation"); // 返回视图 return 是为了让 Spring IOC 容器初始化时自动扫描到 是为了映射请求路径, 这里因为类与方法上都有映射所以访问时应该是 /HelloController/h1; 方法中声明 Model 类型的参数是为了把 Action 中的数据带到视图中 ; 方法返回的结果是视图的名称 hello, 加上配置文件中的前后缀变成 WEB-INF/jsp/hello.jsp 7 创建视图层 1. 在 WEB-INF/ jsp 目录中创建 hello.jsp, 视图可以直接取出并展示从 Controller 带回的信息 ; 2. 可以通过 EL 表示取出 Model 中存放的值, 或者对象 ; <%@ page contenttype="text/html;charset=utf-8" language="java" %> <html> <head> <title> 跳转页面 </title> </head> <body> ${msg </body> </html> 8 配置 Tomcat 运行 配置 Tomcat, 开启服务器, 访问对应的请求路径!

82 小结 OK, 运行成功 实现步骤其实非常的简单 : 1. 新建一个 web 项目 2. 导入相关 jar 包 3. 编写 web.xml, 注册 DispatcherServlet 4. 编写 springmvc 配置文件 5. 接下来就是去创建对应的控制类, controller 6. 最后完善前端视图和 controller 之间的对应 7. 测试运行调试使用 springmvc 必须配置的三大件 : 处理器映射器 处理器适配器 视图解析器通常, 我们只需要手动配置视图解析器, 而处理器映射器和处理器适配器只需开启注解驱动即可, 而省去了大段的 xml 配置再来回顾下原理吧 ~ 控制器 控制器 Controller 控制器复杂提供访问应用程序的行为, 通常通过接口定义或注解定义两种方法实现 控制器负责解析用户的请求并将其转换为一个模型 在 Spring MVC 中一个控制器类可以包含多个方法在 Spring MVC 中, 对于 Controller 的配置方式有很多种实现 Controller 接口

83 Controller 是一个接口, 在 org.springframework.web.servlet.mvc 包下, 接口中只有一个方法 ; // 实现该接口的类获得控制器功能 public interface Controller { // 处理请求且返回一个模型与视图对象 ModelAndView handlerequest(httpservletrequest var1, HttpServletResponse var2) throws Exception; 测试 1. 新建一个 Moudle,SpringMVC-04-Controller 将刚才的 03 拷贝一份, 我们进行操作! 2. 删掉 HelloController mvc 的配置文件只留下视图解析器! 3. 编写一个 Controller 类,HelloController // 定义控制器 // 注意点 : 不要导错包, 实现 Controller 接口, 重写方法 ; public class HelloController implements Controller public ModelAndView handlerequest(httpservletrequest httpservletrequest, HttpServletResponse httpservletresponse) throws Exception { // 创建模型视图 ModelAndView mv = new ModelAndView(); // 添加数据 mv.addobject("msg","hellospringmvc"); // 添加视图 mv.setviewname("hello"); return mv; 的类 3 编写完毕后, 去 Spring 配置文件中注册请求的 bean;name 对应请求路径,class 对应处理请求 <bean id="/hello" class="com.njxh.controller.hellocontroller"/> 4 编写前端 hello.jsp, 注意在 WEB-INF/jsp 目录下编写, 对应我们的视图解析器 <%@ page contenttype="text/html;charset=utf-8" language="java" %> <html> <head> <title> 跳转页面 </title> </head> <body> ${msg </body> </html>

84 OK! 5 配置 Tomcat 运行测试, 我这里没有项目发布名配置的就是一个 /, 所以请求不用加项目名, 说明 : 实现接口 Controller 定义控制器是较老的办法缺点是 : 一个控制器中只有一个方法, 如果要多个方法则需要定义多个 Controller; 定义的方式比较麻烦 注解类型用于声明 Spring 类的实例是一个控制器 ( 在讲 IOC 时还提到了另外 3 个注解 ); Spring 可以使用扫描机制来找到应用程序中所有基于注解的控制器类, 为了保证 Spring 能找到你的控制器, 需要在配置文件中声明组件扫描 <!-- 自动扫描指定的包, 下面所有注解类交给 IOC 容器管理 --> <context:component-scan base-package="com.kuang.controller"/> 增加一个 ControllerTest2 类, public class HelloController2 public String hello1(model mv) { // 添加数据 mv.addattribute("msg","hellosrpingannotation"); return "hello"; 运行 Tomcat 测试 可以发现, 我们的两个请求都可以指向一个视图, 但是页面结果的结果是不一样的, 从这里可以看 出视图是被复用的, 而控制器与视图之间是弱偶合关系 注解方式是平时使用的最多的方式!

85 RequestMapping 注解用于映射 url 到控制器类或一个特定的处理程序方法 可用于类或方法上 用于类上, 表示类中所有的响应请求的方法都是以该地址作为父路径 为了测试结论更加准确, 我们可以加上项目测试 myweb public class HelloController2 public String hello1(model mv) { // 添加数据 mv.addattribute("msg","hellorequestmapping"); return "hello"; 访问路径 : / 项目名 / public class HelloController2 public String hello1(model mv) { // 添加数据 mv.addattribute("msg","hellorequestmapping"); return "hello"; 访问路径 : / 项目名 / admin /h1, 需要先指定类的路径再指定方法的 路径 ; RestFul 风格 概念 Restful 就是一个资源定位及资源操作的风格 不是标准也不是协议, 只是一种风格 基于这个风格设计的软件可以更简洁, 更有层次, 更易于实现缓存等机制 功能

86 资源 : 互联网所有的事物都可以被抽象为资源资源操作 : 使用 POST DELETE PUT GET, 使用不同方法对资源进行操作 分别对应添加 删除 修改 查询 传统方法操作资源通过不同的参数来实现不同的效果! 方法单一,post 和 get 查询,GET 新增,POST 更新,POST 删除,GET 或 POST 使用 RestFul 风格操作资源可以通过不同的请求方式来实现不同的效果! 如下 : 请求地址一样, 但是功能可以不同! 查询,GET 新增,POST 更新,PUT 删除,DELETE 学习测试 1 新建一个 public class ControllerTest { 2 在 SpringMVC 注解, 让方法参数的值对应绑定到一个 url 模板变量上 注意 :@PathVariable 注解只能在地址传入参数时使用 // 使用 RestFul 风格, 默认是 public String test(@pathvariable int a,@pathvariable int b, Model mv) { // 存储数据 mv.addattribute("msg","restful 风格 :"+a+b); return "hello"; 3 我们来测试请求查看下

87 4 思考: 使用路径变量的好处? 使路径变得更加简洁 ; 获得参数更加方便, 框架会自动进行类型转换 通过路径变量的类型可以约束访问参数, 如果类型不一样, 则访问不到对应的请求方法, 如这里访问是的路径是 /h1/1/a, 则路径与方法不匹配, 而不会是参数转换失败 5 重新定义一个方法, 修改下对应的参数类型, 再次测试 // 使用 RestFul, = "h2/{a/{b") public String index(@pathvariable int a,@pathvariable String b,model mv) { // 存储数据 mv.addattribute("msg","restful 风格 :"+a+b); return "hello"; 6 使用 method 属性指定请求类型 新增一个方法 // 映射访问路径, 必须是 POST = "h3/{name/{pws",method = RequestMethod.POST) public String index2(@pathvariable String name,@pathvariable String pws,model mv) { // 存储数据 mv.addattribute("msg","restful 风格 :"+name+pws); return "hello"; 定义表单 form

88 page contenttype="text/html;charset=utf-8" language="java" %> <html> <head> <title>$title$</title> </head> <body> <form action="/h3/name/pws" method="post"> <input type="submit"> </form> </body> </html> 我们使用浏览器地址栏进行访问默认是 Get 请求, 会报错 405: 如果将 POST 修改为 GET 则正常了 ; // 映射访问路径, 必须是 POST = "h3/{name/{pws",method = RequestMethod.GET) public String index2(@pathvariable String name,@pathvariable String pws,model mv) { // 存储数据 mv.addattribute("msg","restful 风格 :"+name+pws); return "hello"; 8 运行测试 小结 :

89 Spring MVC 注解能够处理 HTTP 请求的方法, 比如 GET, PUT, POST, DELETE 以及 PATCH 所有的地址栏请求默认都是 HTTP GET 类型的 方法级别的注解变体有如下几个 是一个组合注解, 平时使用的会比较多! =RequestMethod.GET) public String test4(@pathvariable int a,@pathvariable int b,model mv) { // 存储数据 mv.addattribute("msg","restful 风格 :"+a+b); return "hello"; 扩展 : 小黄鸭扩展法 场景一 : 我们都有过向别人 ( 甚至可能向完全不会编程的人 ) 提问及解释编程问题的经历, 但是很多时候就在我们解释的过程中自己却想到了问题的解决方案, 然后对方却一脸茫然 场景二 : 你的同行跑来问你一个问题, 但是当他自己把问题说完, 或说到一半的时候就想出答案走 了, 留下一脸茫然的你 其实上面两种场景现象就是所谓的小黄鸭调试法 (Rubber Duck Debuging), 又称橡皮鸭调试 法, 它是我们软件工程中最常使用调试方法之一 此概念据说来自 程序员修炼之道 书中的一个故事, 传说程序大师随身携带一只小黄鸭, 在调试 代码的时候会在桌上放上这只小黄鸭, 然后详细地向鸭子解释每行代码, 然后很快就将问题定位修复 了 页面跳转 ModelAndView 设置 ModelAndView 对象, 根据 view 的名称, 和视图解析器跳到指定的页面. 页面 : { 视图解析器前缀 + viewname +{ 视图解析器后缀

90 <!-- 视图解析器 :DispatcherServlet 给他的 ModelAndView--> <bean class="org.springframework.web.servlet.view.internalresourceviewresolver" id="internalresourceviewresolver"> <!-- 前缀 --> <property name="prefix" value="/web-inf/jsp/"/> <!-- 后缀 --> <property name="suffix" value=".jsp"/> </bean> 对应的 controller 类 public class ControllerTest2 implements Controller public ModelAndView handlerequest(httpservletrequest httpservletrequest, HttpServletResponse httpservletresponse) throws Exception { // 创建数据模型 ModelAndView mv = new ModelAndView(); // 存储数据 mv.addobject("msg"," 数据跳转方式一 :ModelAndView"); // 存储视图 mv.setviewname("hello"); return mv; Servlet API 接口通过设置 ServletAPI, 不需要视图解析器. 1 通过 HttpServletResponse 进行输出 2 通过 HttpServletResponse 实现重定向 3 通过 public class ControllerTest3 { // 获取数据, public void test(httpservletrequest request, HttpServletResponse response) throws ServletException, IOException { // 获取数据 String name = request.getparameter("name"); // 存储数据 request.setattribute("msg",name); // 跳转页面 request.getrequestdispatcher("/web- INF/jsp/hello.jsp").forward(request,response); //

91 public void test2(httpservletrequest request, HttpServletResponse response) throws IOException { // 发送数据 response.getwriter().println(" 天哥牛逼 "); // public void test3(httpservletrequest request, HttpServletResponse response) throws IOException { // 重定向跳转 response.sendredirect( "/index.jsp"); Spring MVC 实现 ( 无需视图解析器 ) public class ControllerTest4 { // 无需视图解析跳转方式 // public String test1() { return "/index.jsp"; // public String test2() { return "forward:/index.jsp"; // public String test3() { return "redirect:/index.jsp"; Spring MVC 实现 ( 需要视图解析器 ) 重定向, 不需要视图解析器, 本质就是重新请求一个新地方嘛, public class ControllerTest5 { // 配合视图解析跳转页面 // 默认转发

92 @GetMapping("test1") public String test1(model mv) { // 存储数据 mv.addattribute("msg","spring MVC 配合视图解析器跳转页面 "); public class ControllerTest5 { // 配合视图解析跳转页面 // public String test1(model mv) { // 存储数据 mv.addattribute("msg","spring MVC 配合视图解析器跳转页面 "); return public String test2() { // 重定向本身就是重新访问一个新路径, 如果使用重定向访问一个路径, 必须将 // 视图解析器注释掉, 无法会走视图解析进行拼接 return "redirect:/index.jsp"; // 如果使用重定向进行访问一个请求的话, 则不会走视图解析器 //return "redirect/controller3/test1"; 数据处理 接收请求的数据 1 提交的 url 路劲中的参数名称和处理方法上的参数名一致提交数据 : 小丁处理方法 public String test1(string name) { System.out.println(name); return "hello"; 2 提交的 url 路劲中的参数名称和处理方法的参数名不一致 提交请求 : 小丁

93 定义方法的参数时, 注解, 不管请求的 url 参数名和处理方法的参数名是 否相同, 必须加上 这样方便我们后期维护时, 可以一眼看出这个参数是需要前端传输数据的 处理方法 public String test2(@requestparam("username") String name) { System.out.println(name); return "hello"; 3 提交表单,post 请求, 处理方法使用对象参数进行接收提交请求 : 小丁 &age=25 注意 : 1 form 表单中 input 的 name 属性值必须和对象的属性名一致 2 属性名一致, 则自动注入值 3 属性名不一致, 不一致的属性名, 则不会注入值实体类 : 在阅读以 Java 类代码之前, 请先看看这两篇文章 spring MVC 中 lombok 的几个基本注解 : 该注解使用在类上, 会自动添加 getter setter equals canequal hashcode tostring 等方法 使用后添加一个构造函数, 该构造函数含有所有已声明字段属性参数 使用后创建一个无参构造函数 使用在类上, 默认任何非静态字段以名称 - 值的形式包含在方法的输出中 1 如果需要可以通过注释参数 includefieldnames 来控制输出中是否包含的属性名称 2 可以通过 exclude 参数中包含字段名称, 可以从生成的方法的输出中排除特定字段 3 可以通过 callsuper 参数控制超类 tostring 方法的输出 用在类上, 会生成含所有参数的构造方法,get 方法, 此外还提供了 equals hashcode tostring 方法 注意 : 没有 setter // public class DmUser { private Integer urid; private String urusername; private String urpassword; private String ursex; private Integer urage;

94 private String urname; private String urphone; lombok 注解失效解决 // 自动生成 get set tostring hashcode canequal // // 自动生成包含所有变量的构造方法 public class User { private int id; private String name; private int age; public String test3(user user) { System.out.println(user); return "hello"; 将请求的数据显示到前端页面上 通过 ModelAndView 方式 我们前面一直都是如此. public ModelAndView test1(string name) { // 创建模型视图 ModelAndView mv = new ModelAndView(); // 添加数据 mv.addobject("msg",name); // 添加视图 mv.setviewname("hello"); // 返回模型视图 return mv; 通过 ModelMap public String test3(@requestparam("username") String name,modelmap map) { // 添加数据 map.addattribute("msg",name); return "hello";

95 通过 Model public String test3(user user, Model mv) { // 添加数据 mv.addattribute("msg",user); return "hello"; 对比 : 就对于新手而言简单来说使用区别就是 : Model 只有寥寥几个方法只适合用于储存数据, 简化了新手对于 Model 对象的操作和理解 ; ModelMap 继承了 LinkedMap, 除了实现了自身的一些方法, 同样的继承 LinkedMap 的方法和特性 ; ModelAndView 可以在储存数据的同时, 可以进行设置返回的逻辑视图, 进行控制展示层的跳转 当然更多的以后开发考虑的更多的是性能和优化, 就不能单单仅限于此的了解 请使用 80% 的时间打好扎实的基础, 剩下 18% 的时间研究框架,2% 的时间去学点英文, 框架的官方文档永远是最好的教程 乱码处理 测试步骤 : 1 我们可以在首页编写一个提交的表单 <form action="/e/t" method="post"> <input type="text" name="name"> <input type="submit"> </form> 2 public class Encoding public String test(model model,string name){ model.addattribute("msg",name); // 获取表单提交的值 return "hello"; // 跳转到 test 页面显示输入的值 3 测试结果

96 不得不说, 乱码问题是在我们开发中十分常见的问题, 也是让我们程序猿比较头大的问题! 以前乱码问题通过过滤器解决, 而 SpringMVC 给我们提供了一个过滤器, 可以在 web.xml 中配置. 修改了 xml 文件需要重启服务器! <filter> <filter-name>encoding</filter-name> <filter-class>org.springframework.web.filter.characterencodingfilter</filterclass> <init-param> <param-name>encoding</param-name> <param-value>utf-8</param-value> </init-param> </filter> <filter-mapping> <filter-name>encoding</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> 但是我们发现, 有些极端情况下. 这个过滤器对 get 的支持不好. 处理方法 : 1 修改 tomcat 配置文件 : 设置编码! <Connector URIEncoding="utf-8" port="8080" protocol="http/1.1" connectiontimeout="20000" redirectport="8443" /> 2 自定义过滤器 package com.njxh.filter; import javax.servlet.*; import javax.servlet.http.httpservletrequest; import javax.servlet.http.httpservletrequestwrapper; import javax.servlet.http.httpservletresponse; import java.io.ioexception; import java.io.unsupportedencodingexception; import java.util.map; /** * 解决 get 和 post 请求全部乱码的过滤器 */

97 public class GenericEncodingFilter implements Filter public void destroy() public void dofilter(servletrequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { // 处理 response 的字符编码 HttpServletResponse myresponse=(httpservletresponse) response; myresponse.setcontenttype("text/html;charset=utf-8"); // 转型为与协议相关对象 HttpServletRequest httpservletrequest = (HttpServletRequest) request; // 对 request 包装增强 HttpServletRequest myrequest = new MyRequest(httpServletRequest); chain.dofilter(myrequest, public void init(filterconfig filterconfig) throws ServletException { // 自定义 request 对象,HttpServletRequest 的包装类 class MyRequest extends HttpServletRequestWrapper { private HttpServletRequest request; // 是否编码的标记 private boolean hasencode; // 定义一个可以传入 HttpServletRequest 对象的构造函数, 以便对其进行装饰 public MyRequest(HttpServletRequest request) { super(request);// super 必须写 this.request = request; // public Map getparametermap() { // 先获得请求方式 String method = request.getmethod(); if (method.equalsignorecase("post")) { // post 请求 try { // 处理 post 乱码 request.setcharacterencoding("utf-8"); return request.getparametermap(); catch (UnsupportedEncodingException e) { e.printstacktrace(); else if (method.equalsignorecase("get")) { // get 请求 Map<String, String[]> parametermap = request.getparametermap(); if (!hasencode) { // 确保 get 手动编码逻辑只运行一次 for (String parametername : parametermap.keyset()) { String[] values = parametermap.get(parametername);

98 if (values!= null) { for (int i = 0; i < values.length; i++) { try { // 处理 get 乱码 values[i] = new String(values[i].getBytes("ISO "), "utf-8"); catch (UnsupportedEncodingException e) { e.printstacktrace(); hasencode = true; return parametermap; return super.getparametermap(); // public String getparameter(string name) { Map<String, String[]> parametermap = getparametermap(); String[] values = parametermap.get(name); if (values == null) { return null; return values[0]; // 取回参数的第一个值 // public String[] getparametervalues(string name) { Map<String, String[]> parametermap = getparametermap(); String[] values = parametermap.get(name); return values; 这个也是我在网上找的一些大神写的, 一般情况下,SpringMVC 默认的乱码处理就已经能够很好的解决了! 然后在 web.xml 中配置这个过滤器即可! 乱码问题, 需要平时多注意, 在尽可能能设置编码的地方, 都设置为统一编码 UTF-8! JSON 交互处理 什么是 JSON? JSON(JavaScript Object Notation,JS 对象标记 ) 是一种轻量级的数据交换格式, 目前使用特别广泛采用完全独立于编程语言的文本格式来存储和表示数据简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言易于人阅读和编写, 同时也易于机器解析和生成, 并有效地提升网络传输效率

99 在 JavaScirpt 语言中, 一切都是对象 因此, 任何 JavaScript 支持的类型都可以通过 JSON 来表示, 例如字符串 数字 数组等 看看他的要求和语法格式 对象表示为键值对, 数据由逗号分隔花括号保存对象方括号保存数据 JSON 键值对是用来保存 JavaScript 对象的一种方式, 和 JavaScript 对象的写法也大同小异, 键 / 值对组合中的键名写在前面并使用双引号 "" 包裹, 使用冒号 : 分隔, 然后紧接着值 : {"name":"xiaoding" {"age":"12" {"sex":" 男 " 很多人搞不清楚 JSON 和 Java Scirpt 对象的关系, 甚至连谁是谁都分不清楚 其实, 可以这么理解 : JSON 是 Java Script 对象的字符串表示法, 它使用文本表示一个 JS 对象的信息, 本质是一个字符串 var a = {name:" 小丁 ",age:12,sex:" 男 " // 这是一个对象, 注意键名也是可以使用引号包裹的 var b = '{"name":" 小丁 ","age":"12","sex":" 男 "' // 这是一个 JSON 字符串, 本质是一个字符 串 JSON 和 JavaScirpt 对象互转 要实现从 JSON 字符串转换为 Java Script 对象, 使用 JSON.parse() 方法 var obj = JSON.parse('{"a": "Hello", "b": "World"'); // 结果是 {a: 'Hello', b: 'World' 使用 Jackson 解析 JSON 数据 使用 Jackson 解析 JSON 数据 Jackson 应该是目前比较好的 json 解析工具了当然工具不止这一个, 比如还有阿里巴巴的 fastjson 等等 我们这里使用 Jackson, 使用它需要导入它的 jar 包 ; <dependency> <groupid>com.fasterxml.jackson.core</groupid> <artifactid>jackson-databind</artifactid> <version>2.12.2</version> </dependency> 配置 web.xml <?xml version="1.0" encoding="utf-8"?>

100 <web-app xmlns=" xmlns:xsi=" xsi:schemalocation=" version="4.0"> <!-- 关联 Spring MVC 配置文件 --> <init-param> <param-name>contextconfiglocation</param-name> <param-value>classpath:springmvc-servlet.xml</param-value> </init-param> <!-- 启动级别 -1 服务器启动的时候, 这个程序跟着启动 --> <load-on-startup>1</load-on-startup> </servlet> <!--/ 匹配所有的请求 : ( 不包括 jsp)--> <!--/* 匹配所有的请求 :( 包括 jsp) --> <servlet-mapping> <servlet-name>springmvc</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> <!-- 注册 DispatcherServlet --> <servlet> <servlet-name>springmvc</servlet-name> <servletclass>org.springframework.web.servlet.dispatcherservlet</servlet-class> <!-- 拦截器 --> <filter> <filter-name>encoding</filter-name> <filterclass>org.springframework.web.filter.characterencodingfilter</filter-class> <init-param> <param-name>encoding</param-name> <param-value>utf-8</param-value> </init-param> </filter> <filter-mapping> <filter-name>encoding</filter-name> <url-pattern>/</url-pattern> </filter-mapping> </web-app> 配置 springmvc-servlet.xml 文件 <?xml version="1.0" encoding="utf-8"?> <beans xmlns=" xmlns:xsi=" xmlns:context=" xmlns:mvc=" xsi:schemalocation="

101 <!-- 自动扫描包, 让指定包下的注解生效, 由 IOC 容器同一管理 --> <context:component-scan base-package="com.njxh.controller"/> <!-- 定义视图解析器 --> <bean id="internalresourceviewresolver" class="org.springframework.web.servlet.view.internalresourceviewresolver"> <!-- 定义前缀 --> <property name="prefix" value="/web-inf/jsp/"/> <!-- 定义后缀 --> <property name="suffix" value=".jsp"/> </bean> </beans> 编写一个 @AllArgsConstructor public class User { private int id; private String name; private int age; 的用法 这里我们需要两个新东西, 一个是 ObjectMapper 对象, 我们看下具体 编写一个 Controller public class // 当前方法不走视图解析器, 并向请求页面返回一个 String public String test() throws JsonProcessingException { // 创建一个 jackson 的对象映射器, 用来解析数据 ObjectMapper mapper = new ObjectMapper(); // 创建一个对象 User user = new User(0, " 小丁 ", 25); // 将我们的对象解析成为 json 格式 String str = mapper.writevalueasstring(user); // 注解, 这里会将 str 转成 json 格式返回 ; 十分方便 return str; 配置 Tomcat, 启动测试一下!

102 发现出现了乱码问题, 我们需要设置一下他的编码格式为 utf-8, 以及它返回的类型 ; 的 produces 属性来实现, 修改下代码 //produces: = "/test1",produces = "application/json;charset=utf-8") 再次测试, 乱码问题 OK! 注意: 使用 JSON 记得处理乱码问题 JSON 数据统一乱码解决方案上一种方法比较麻烦, 如果项目中有许多请求则每一个都要添加, 可以通过 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.mappingjackson2httpmessageconvert er"> <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> 返回 JSON 字符统一解决

103 这样子, 里面所有的方法都只会返回 json 字符串了, 不用再 我们在前后端分离开发中, 十分便 public class // 当前方法不走视图解析器, 并向请求页面返回一个 String public String test() throws JsonProcessingException { // 创建一个 jackson 的对象映射器, 用来解析数据 ObjectMapper mapper = new ObjectMapper(); // 创建一个对象 User user = new User(0, " 小丁 ", 25); // 将我们的对象解析成为 json 格式 String str = mapper.writevalueasstring(user); // 注解, 这里会将 str 转成 json 格式返回 ; 十分方便 return str; 集合测试 public String test2() throws JsonProcessingException { // 创建一个 jackson 的对象映射器, 用来解析数据 ObjectMapper mapper = new ObjectMapper(); // 创建一个对象 User user = new User(0," 你好 ",0); User user2 = new User(0," 你好 ",0); User user3 = new User(0," 你好 ",0); User user4 = new User(0," 你好 ",0); List<User> list = new ArrayList<User>(); list.add(user); list.add(user2); list.add(user3); list.add(user4); // 将我们的对象解析成为 json 格式 String str = mapper.writevalueasstring(list); return str; 测试结果 : 时间测试 新增一个方法

104 @RequestMapping("/test3") public String test3() throws JsonProcessingException { ObjectMapper mapper = new ObjectMapper(); // 创建时间一个对象,java.util.Date Date date = new Date(); // 将我们的对象解析成为 json 格式 String str = mapper.writevalueasstring(date); return str; 测试结果 : 默认日期格式会变成一个数字, 是 1970 年 1 月 1 日到当前日期的毫秒数! Jackson 默认是会把时间转成 timestamps 形式 解决方案 : 取消 timestamps 形式, public String test4() throws JsonProcessingException { ObjectMapper mapper = new ObjectMapper(); // 不使用时间戳的方式 mapper.configure(serializationfeature.write_dates_as_timestamps, false); // 自定义日期格式对象 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); // 指定日期格式 mapper.setdateformat(sdf); Date date = new Date(); String str = mapper.writevalueasstring(date); return str; 运行结果 : 成功的输出了时间!

105 定义一个工具类来解决 JSON 数据转换的问题 下 如果要经常使用的话, 这样是比较麻烦的, 我们可以将这些代码封装到一个工具类中 ; 我们去编写 package com.njxh.utils; import com.fasterxml.jackson.core.jsonprocessingexception; import com.fasterxml.jackson.databind.objectmapper; import com.fasterxml.jackson.databind.serializationfeature; import java.text.simpledateformat; /** JSONUtils JSON 工具类 xiaoding 2021/3/29 8: */ public class JSONUtils { public static String getjson(object o) throws JsonProcessingException { return getjson(o,"yyyy-mm-dd HH:mm:ss"); public static String getjson(object o,string dateformat) throws JsonProcessingException { // 创建 ObjectMapper 对象 ObjectMapper mapper = new ObjectMapper(); // 不使用, 默认的时间转换 ( 时间戳 :1970~ 现在时间的毫秒数 ) mapper.configure(serializationfeature.write_dates_as_timestamps,false); // 创建时间解析器对象 SimpleDateFormat dateformat1 = new SimpleDateFormat(dateFormat); // 引入时间解析器 mapper.setdateformat(dateformat1); // 解析内容并返回 return mapper.writevalueasstring(o);

106 我们使用工具类, public String test5() throws JsonProcessingException { Date date = new Date(); String json = JsonUtils.getJson(date); return json; fastjson 解析 JSON 数据 fastjson.jar 是阿里开发的一款专门用于 Java 开发的包, 可以方便的实现 json 对象与 JavaBean 对象的转换, 实现 JavaBean 对象与 json 字符串的转换, 实现 json 对象与 json 字符串的转换 实现 json 的转换方法很多, 最后的实现结果都是一样的 导入 fastjson 的依赖 <dependency> <groupid>com.alibaba</groupid> <artifactid>fastjson</artifactid> <version>1.2.75</version> </dependency> 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 字符串之间的相互转化代码测试, 我们新建一个 FasJsonDemo 类 package com.njxh.controller; import com.alibaba.fastjson.json; import com.alibaba.fastjson.jsonobject; import com.njxh.pojo.user; import org.springframework.web.bind.annotation.requestmapping; import org.springframework.web.bind.annotation.restcontroller; import java.util.date;

107 /** JSONController2 使用 fastjson.jar 解析 JSON 数据 xiaoding 2021/3/29 9:47 public class JSONController2 public String test1() { // 创建用户对象 User user = new User(0," 小丁 ",25); // 将 JAVA 对象转换 JSON 字符串 String str = JSON.toJSONString(user); System.out.println(str); System.out.println("==========="); // 将 JSON 字符串转换成 Java 对象 User user1 = JSON.parseObject(str,User.class); System.out.println(user1); System.out.println("==========="); // 将 JAVA 对象转换成 JSON 对象 JSONObject jsonobject = (JSONObject) JSON.toJSON(user); System.out.println(jsonObject.get("name")); System.out.println("============="); //JSON 对象转 Java 对象 User user2 = JSON.toJavaObject(jsonObject,User.class); System.out.println(user2); // 解析时间对象 System.out.println(JSON.toJSONStringWithDateFormat(new Date(),"yyyy-MMdd HH:mm:ss")); return JSON.toJSONString(user); 这种工具类, 我们只需要掌握使用就好了, 在使用的时候在根据具体的业务去找对应的实现 和以前的 commons-io 那种工具包一样, 拿来用就好了! Json 在我们数据传输中十分重要, 一定要学会使用! SSM 框架整合 整合 MyBatis 环境搭建 : IDEA Tomcat JDK14 Maven 3.6 MySql

108 要求 : 熟练掌握 MySql 数据库,Spring JavaWeb 以及 MyBtais 知识, 简单的前端知识 1 过滤静态资源 <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> 如果运行程序时, 提示不支持发行版本 5 或者其他版本 解决步骤 1: 将解决步骤 1 的最后一步, 替换我这个 <properties> <project.build.sourceencoding>utf- 8</project.build.sourceEncoding> <project.reporting.outputencoding>utf- 8</project.reporting.outputEncoding> <java.version>14</java.version> <maven.compiler.source>14</maven.compiler.source> <maven.compiler.target>14</maven.compiler.target> <encoding>utf-8</encoding> </properties> 2 导入依赖 <dependencies> <!-- 测试 Junit --> <dependency> <groupid>junit</groupid> <artifactid>junit</artifactid> <version>4.13</version> </dependency> <!-- SpringMVC SpringJDBC -->

109 <dependency> <groupid>org.springframework</groupid> <artifactid>spring-webmvc</artifactid> <version>5.3.5</version> </dependency> <dependency> <groupid>org.springframework</groupid> <artifactid>spring-jdbc</artifactid> <version>5.3.5</version> </dependency> <!-- Servlet jsp jstl standard ---> <dependency> <groupid>javax.servlet</groupid> <artifactid>servlet-api</artifactid> <version>2.5</version> </dependency> <dependency> <groupid>javax.servlet.jsp</groupid> <artifactid>jsp-api</artifactid> <version>2.2</version> </dependency> <dependency> <groupid>javax.servlet.jsp.jstl</groupid> <artifactid>jstl-api</artifactid> <version>1.2</version> </dependency> <dependency> <groupid>apache-taglibs</groupid> <artifactid>standard</artifactid> <version>1.1.2</version> </dependency> <!-- 简化实体类程序的 jar --> <dependency> <groupid>org.projectlombok</groupid> <artifactid>lombok</artifactid> <version> </version> <scope>provided</scope> </dependency> <!-- JOSN 工具包 --> <dependency> <groupid>com.alibaba</groupid> <artifactid>fastjson</artifactid> <version>1.2.75</version> </dependency> <!-- AOP 需要额外的包 --> <dependency> <groupid>org.aspectj</groupid> <artifactid>aspectjweaver</artifactid> <version>1.9.6</version> </dependency> <dependency> <groupid>aopalliance</groupid> <artifactid>aopalliance</artifactid> <version>1.0</version>

110 </dependency> <dependency> <groupid>javax.annotation</groupid> <artifactid>javax.annotation-api</artifactid> <version>1.3.2</version> </dependency> <!-- mysql --> <dependency> <groupid>mysql</groupid> <artifactid>mysql-connector-java</artifactid> <version>8.0.22</version> </dependency> <!-- MyBtais --> <dependency> <groupid>org.mybatis</groupid> <artifactid>mybatis</artifactid> <version>3.5.6</version> </dependency> <dependency> <groupid>org.mybatis</groupid> <artifactid>mybatis-spring</artifactid> <version>2.0.6</version> </dependency> <!-- cp30 连接池 --> <dependency> <groupid>com.mchange</groupid> <artifactid>c3p0</artifactid> <version> </version> </dependency> </dependencies> 3 建立基本项目架构和配置架构 com.njxh.pojo com.njxh.dao com.njxh.service com.njxh.controller 创建 MyBtais 配置文件 mybatis.xml( 注意 : 所有配置文件统一放在 resource 目录汇总 ) <?xml version="1.0" encoding="utf-8"?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//dtd Config 3.0//EN" " <configuration> <typealiases> <package name="com.njxh.pojo"/> </typealiases> <!-- 配置映射文件路径, 可根据自己的需要来配置, 现在看不懂没关系, 往下看 --> <mappers> <package name="com.njxh.dao"/> </mappers>

111 </configuration> 配置数据库文件,database.properties jdbc.driver=com.mysql.cj.jdbc.driver jdbc.url=jdbc:mysql://localhost:3306/mybatis? useunicode=true&characterencoding=utf- 8&allowPublicKeyRetrieval=true&useSSL=false&serverTimezone=UTC jdbc.username=root jdbc.password=dingtianci123 定义 Spring 总配置文件 ( 用于管理其他 Spring 配置文件 ) <?xml version="1.0" encoding="utf-8"?> <beans xmlns=" xmlns:xsi=" xmlns:context=" xsi:schemalocation=" </beans> 4 运行 SQL 语句, 创建表 CREATE DATABASE `ssmbuild`; USE `ssmbuild`; DROP TABLE IF EXISTS `books`; CREATE TABLE `books` ( `bookid` INT(10) NOT NULL AUTO_INCREMENT COMMENT ' 书 id', `bookname` VARCHAR(100) NOT NULL COMMENT ' 书名 ', `bookcounts` INT(11) NOT NULL COMMENT ' 数量 ', `detail` VARCHAR(200) NOT NULL COMMENT ' 描述 ', KEY `bookid` (`bookid`) ) ENGINE=INNODB DEFAULT CHARSET=utf8 INSERT INTO `books`(`bookid`,`bookname`,`bookcounts`,`detail`)values (1,'Java',1,' 从入门到放弃 '), (2,'MySQL',10,' 从删库到跑路 '), (3,'Linux',5,' 从进门到进牢 '); 5 创建数据库表的实体类 Books ( 项目的 pojo 层 )

112 @Data public class Books { private int bookid; private String bookname; private int bookcounts; private String detail; 6 创建映射文件和映射接口 ( 项目的 dao 层 ) public interface BookMapper { // 根据 id 查找图书 public Books querybookbyid(int bookid); // 返回全部图书 public List<Books> queryallbook(); // 根据图书名称名称查找图书 public List<Books> querybookname(string bookname); // 添加图书 public int addbook(books books); // 修改图书 public int updatebook(books books); // 删除图书 public int deletebook(int bookid); <?xml version="1.0" encoding="utf-8"?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//dtd Config 3.0//EN" " <mapper namespace="com.njxh.dao.bookmapper"> <select id="querybookbyid" parametertype="int" resulttype="com.njxh.pojo.books"> select * from books where bookid = #{bookid </select> <select id="queryallbook" resulttype="com.njxh.pojo.books"> select * from books </select> <select id="querybookname" parametertype="string" resulttype="com.njxh.pojo.books"> select * from books where bookname like #{bookname </select> <insert id="addbook" parametertype="com.njxh.pojo.books"> insert into books(bookname,bookcounts,detail) values (#{bookname,# {bookcounts,#{detail) </insert> <update id="updatebook" parametertype="com.njxh.pojo.books"> update books set bookname = #{bookname,bookcounts=# {bookcounts,detail=#{detail where bookid = #{bookid

113 </update> <delete id="deletebook" parametertype="int"> delete from books where bookid = #{bookid </delete> </mapper> 注意 : xml 文件名和映射接口名称大小写要一直, 除了后缀名 xml 文件中的 namespace 的值对应映射接口所在的路径和名称 7 定义业务逻辑成( 项目的 service 层 ) 定义业务接口 public interface BookService { // 根据 id 查找图书 public Books querybookbyid(int bookid); // 返回全部图书 public List<Books> queryallbook(); // 根据图书名称名称查找图书 public List<Books> querybookname(string bookname); // 添加图书 public int addbook(books books); // 修改图书 public int updatebook(books books); // 删除图书 public int deletebook(int bookid); // 使用注解自动将当前类注册到 spring public class BookServiceImpl implements BookService { // = "bookmapper") private BookMapper bookmapper; public void setbookmapper(bookmapper bookmapper) { this.bookmapper = public Books querybookbyid(int bookid) { return public List<Books> queryallbook() { return

114 public List<Books> querybookname(string bookname) { return public int addbook(books books) { return public int updatebook(books books) { return public int deletebook(int bookid) { return bookmapper.deletebook(bookid); 到此底层需求基本编写完成! 整合 Spring 层 1 配置整合 mybatis 的 Spring 的文件,spring-jdbc.xml <?xml version="1.0" encoding="utf-8"?> <beans xmlns=" xmlns:xsi=" xmlns:context=" xsi:schemalocation=" <!-- 整合 MyBatis --> <!-- 1 引入数据库的配置文件 --> <context:property-placeholder location="classpath:db.properties"/> <!-- 2 配置数据源 ( 数据库连接池 ) --> <!-- 数据库连接池 dbcp 半自动化操作不能自动连接 c3p0 自动化操作 ( 自动的加载配置文件并且设置到对象里面 ) --> <bean id="datasource" class="com.mchange.v2.c3p0.combopooleddatasource"> <!-- 配置连接池属性 --> <property name="driverclass" value="${jdbc.driver"/> <property name="jdbcurl" value="${jdbc.url"/> <property name="user" value="${jdbc.username"/> <property name="password" value="${jdbc.password"/> <!-- c3p0 连接池的私有属性 --> <property name="maxpoolsize" value="30"/> <property name="minpoolsize" value="10"/> <!-- 关闭连接后不自动 commit --> <property name="autocommitonclose" value="false"/> <!-- 获取连接超时时间 -->

115 <property name="checkouttimeout" value="10000"/> <!-- 当获取连接失败重试次数 --> <property name="acquireretryattempts" value="2"/> </bean> <!-- 3 配置 SqlSessionFactory 对象 --> <bean id="sqlsessionfactory" class="org.mybatis.spring.sqlsessionfactorybean"> <!-- 注入数据库连接池 --> <property name="datasource" ref="datasource"/> </bean> <!-- 关联 MyBatis 配置文件 --> <property name="configlocation" value="classpath:mybatis.xml"/> <!-- 4 配置扫描包, 动态实现 Dao 接口注入到 spring 容器中 --> <bean class="org.mybatis.spring.mapper.mapperscannerconfigurer"> <!-- 注入 sqlsessionfactory --> <property name="sqlsessionfactorybeanname" value="sqlsessionfactory"/> <!-- 定义需要扫描类的位置 --> <property name="basepackage" value="com.njxh.dao"/> </bean> </beans> 2 配置整合 service 层的配置文件,spring-service.xml <?xml version="1.0" encoding="utf-8"?> <beans xmlns=" xmlns:xsi=" xmlns:tx=" xmlns:aop=" xmlns:context=" xsi:schemalocation=" <!-- 扫描 service 相关的 bean --> <context:component-scan base-package="com.njxh.service"/> <!-- 配置事物管理器 --> <bean id="transactionmanager" class="org.springframework.jdbc.datasource.datasourcetransactionmanager"> <!-- 注入数据源 --> <property name="datasource" ref="datasource"/> </bean> <!-- 配置事物通知 --> <tx:advice id="txadvice" transaction-manager="transactionmanager"> <tx:attributes> <tx:method name="add*" propagation="required"/> <tx:method name="delete*" propagation="required"/>

116 <tx:method name="update*" propagation="required"/> <tx:method name="query*" read-only="true"/> <tx:method name="*" read-only="true"/> </tx:attributes> </tx:advice> <!-- AOP 切面 --> <aop:config> <!-- 定义切入点 --> <aop:pointcut id="pointcut" expression="execution(* com.njxh.service.*.* (..))"/> <!-- 引入事物, 并切入 --> <aop:advisor advice-ref="txadvice" pointcut-ref="pointcut"/> </aop:config> </beans> 到此 Spring 层编写完成! 整合 MVC 层 1 配置 web.xml ( 设置拦截器 乱码过滤器 ) <?xml version="1.0" encoding="utf-8"?> <web-app xmlns=" xmlns:xsi=" xsi:schemalocation=" version="4.0"> <!--DispatcherServlet 拦截器 --> <servlet> <servlet-name>dispatcherservlet</servlet-name> <servletclass>org.springframework.web.servlet.dispatcherservlet</servlet-class> <init-param> <param-name>contextconfiglocation</param-name> <!-- 一定要注意 : 我们这里加载的是总的配置文件, 之前被这里坑了!--> <param-value>classpath:spring-context.xml</param-value> </init-param> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>dispatcherservlet</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> <!-- 乱码处理 --> <filter> <filter-name>encodingfilter</filter-name> <filter-class> org.springframework.web.filter.characterencodingfilter </filter-class> <init-param> <param-name>encoding</param-name> <param-value>utf-8</param-value> </init-param> </filter> <filter-mapping>

117 <filter-name>encodingfilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> <!--Session 过期时间 --> <session-config> <session-timeout>15</session-timeout> </session-config> </web-app> 2 配置整合 controller 文件,spring-mvc.xml <?xml version="1.0" encoding="utf-8"?> <beans xmlns=" xmlns:xsi=" xmlns:context=" xmlns:mvc=" xsi:schemalocation=" <!-- 配置 SpringMVC --> <!-- 1. 注解扫描包 --> <context:component-scan base-package="com.njxh.controller"/> <!-- 2. 开启 SpringMVC 注解驱动 --> <mvc:annotation-driven /> <!-- 3. 静态资源默认 servlet 配置 --> <mvc:default-servlet-handler/> <!-- 4. 配置 jsp 显示 ViewResolver 视图解析器 --> <bean class="org.springframework.web.servlet.view.internalresourceviewresolver"> <property name="viewclass" value="org.springframework.web.servlet.view.jstlview" /> <property name="prefix" value="/web-inf/jsp/" /> <property name="suffix" value=".jsp" /> </bean> </beans> 3 定义 controller 层, // 使用注解自动注册 定义 url 映射路径 public class BookController { // = "bookservicetimpl") private BookService bookservice; //set 方法 public void setbookservice(bookservice bookservice) {

118 this.bookservice = bookservice; 4 BookController 类, public String queryallbook(model mv) { // 调用查询的方法 List<Books> list = bookservice.queryallbook(); // 添加数据 mv.addattribute("list",list); return "indexbook"; 5 编写前端页面, 定义初始页面 <%@ page contenttype="text/html;charset=utf-8" language="java" %> <html> <head> <title> 首页 </title> <style> h3{ width: 250px; height: 60px; margin: 100px auto; a{ text-decoration: none; color: black; font-size: 30px; </style> </head> <body> <%-- href 访问图书展示页面的路径 --%> <h3> <a href="${pagecontext.request.contextpath/bookcontroller/queryallbook" > 前往图书展示页面 </a> </h3> </body> </html> 6 定义视图页面, 在 WEB-INF 层里面创建 jsp 目录, 在 jsp 里面创建,indexBook.jsp 页面 <%@ page contenttype="text/html;charset=utf-8" language="java" %> <%@ taglib prefix="c" uri=" %> <html> <head> <title> 图书展示页面 </title> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <!-- 引入 Bootstrap -->

119 <link href=" rel="stylesheet"> </head> <body> <div class="container"> <div class="row"> <div class="col-md-12 column"> <h3> 图书列表 显示所有书籍 </h3> </div> </div> <div class="row"> <div class="col-md-12 column"> <table class="table table-striped"> <%-- 表格头部 --%> <thead> <tr> <td> 书籍编号 :</td> <td> 书籍名字 </td> <td> 书籍数量 </td> <td> 书籍详情 </td> <td> 操作 </td> </tr> </thead> <%-- 表格内容 --%> <tbody> <c:foreach items="${list" var="list"> <tr> <td>${list.bookid</td> <td>${list.bookname</td> <td>${list.bookcounts</td> <td>${list.detail</td> <td><a href=""> 修改 </a> <a href=""> 删除 </a></td> </tr> </tbody> </table> </div> </div> </div> </body> </html> 7 BookController 类, 编写添加书籍的方法

120 @GetMapping("/bookAddPage") public String bookaddpage() { return public String addbook(books books) { // 调用添加书籍的方法 bookservice.addbook(books); return "redirect:/bookcontroller/queryallbook"; 8 在 indexbook.jsp 文件, 编写添加书籍模块 <%-- 在页面 16~17 之间插入此代码 --%> <div class="row" style="margin: 25px 0px"> <div class="col-md-4 column"> <a href="${pagecontext.request.contextpath/bookcontroller/bookaddpage" class="btn btn-primary"> 添加 </a> </div> </div> 9 在 jsp 目录中, 编写添加书籍的页面,addBook,jsp <%@ page contenttype="text/html;charset=utf-8" language="java" %> <html> <head> <title> 添加书籍 </title> <!-- 引入 Bootstrap --> <link href=" rel="stylesheet"> </head> <body> <h3> 添加书籍 </h3> <form action="/bookcontroller/addbook" method="post"> <div class="form-group"> <label for="bookname"> 图书名称 :</label> <input type="text" class="form-control" name="bookname" id="bookname" placeholder=" 请输入图书名称 " required> </div> <div class="form-group"> <label for="bookcounts"> 图书数量 :</label> <input type="text" class="form-control" name="bookcounts" id="bookcounts" placeholder=" 请输入图书数量 " required> </div> <div class="form-group"> <label for="detail"> 图书详情 :</label> <input type="text" class="form-control" name="detail" id="detail" placeholder=" 请输入图书数量 " required> </div> <button type="submit" class="btn btn-default">submit</button> </form>

121 </body> </html> 10 在 BookController 类中, public String bookupdatepage(int bookid,model mv) { // 根据 id 查询相应的图书 Books books = bookservice.querybookbyid(bookid); // 添加数据 mv.addattribute("books",books); return public String updatebook(books books) { // 修改数据 bookservice.updatebook(books); // 返回页面 return "redirect:/bookcontroller/queryallbook"; 11 在 indexbook.jsp 页面中, 修改按钮的地方, 添加响应请求路径 <a href="${pagecontext.request.contextpath/bookcontroller/bookupdatepage? bookid=${list.bookid"> 修改 </a> 12 在 jsp 目录中, 编写修改书籍的页面,updateBook.jsp <%@ page contenttype="text/html;charset=utf-8" language="java" %> <html> <head> <title> 修改书籍 </title> <!-- 引入 Bootstrap --> <link href=" rel="stylesheet"> </head> <body> <form action="/bookcontroller/updatebook" method="post"> <input type="text" name="bookid" value="${books.bookid" hidden> <div class="form-group"> <label for="bookname"> 图书名称 :</label> <input type="text" value="${books.bookname" class="form-control" name="bookname" id="bookname" placeholder=" 请输入图书名称 " required> </div> <div class="form-group"> <label for="bookcounts"> 图书数量 :</label> <input type="text" value="${books.bookcounts" class="form-control" name="bookcounts" id="bookcounts" placeholder=" 请输入图书数量 " required> </div> <div class="form-group"> <label for="detail"> 图书详情 :</label>

122 <input type="text" value="${books.detail" class="form-control" name="detail" id="detail" placeholder=" 请输入图书数量 " required> </div> <button type="submit" class="btn btn-default">submit</button> </form> </body> </html> 13 在 BookController 类中, public String deletebook(int bookid) { // 调用删除的方法 bookservice.deletebook(bookid); // 返回页面 return "redirect:/bookcontroller/queryallbook"; 14 在 indexbook.jsp 页面中, 删除按钮的地方, 添加响应请求路径 <a href="${pagecontext.request.contextpath/bookcontroller/deletebook? bookid=${list.bookid"> 删除 </a> 15 在 BookController 类中, public String querybookname(string querybookname, Model mv) throws IOException { // 调用查询方法 List<Books> list = bookservice.querybookname("%"+querybookname+"%"); // 判断是否查询到内容 if (list.isempty()) { mv.addattribute("err"," 未查询到数据 "); return "indexbook"; // 添加数据 mv.addattribute("list",list); return "indexbook"; 16 在 indexbook.jsp 页面中, 新增根据图书名称查询的模块 <div class="row" style="margin: 25px 0px"> <%-- 添加书籍 --%> <div class="col-md-4 column"> <a href="${pagecontext.request.contextpath/bookcontroller/bookaddpage" class="btn btn-primary"> 添加 </a> </div> <%-- 根据名称搜索书籍 --%>

123 <div class="col-md-4 column"> <form action="${pagecontext.request.contextpath/bookcontroller/querybookname" method="post" class="form-inline"> <input type="text" name="querybookname" required> <input id="anniu" type="submit" value=" 搜索 "> </form> </div> </div> 17 在 indexbook.jsp 页面, 由于新增了图书搜索模块, 所以我们在获取数据时, 需要判断一下, 数据是否查询到新增判断功能, 将替换 indexbook.jsp 里面的 tbody 标签的内容原先内容代码 <tbody> <c:foreach items="${list" var="list"> <tr> <td>${list.bookid</td> <td>${list.bookname</td> <td>${list.bookcounts</td> <td>${list.detail</td> <td><a href=""> 修改 </a> <a href=""> 删除 </a></td> </tr> </c:foreach> </tbody> 需要替换的代码 <tbody> <c:choose> <c:when test="${not empty err> <tr> <td colspan="5" style="text-align: center;"><h2 style="color: red;">${err</h2></td> </tr> </c:when> <c:otherwise> <c:foreach items="${list" var="list"> <tr> <td>${list.bookid</td> <td>${list.bookname</td> <td>${list.bookcounts</td> <td>${list.detail</td> <td><a href=""> 修改 </a> <a href=""> 删除 </a></td> </tr> </c:foreach> </c:otherwise> </c:choose> </tbody>

124 18 如果图书没有搜索到, 返回图书数据, 新增返回所有图书数据模块 <div class="row" style="margin: 25px 0px"> <%-- 添加书籍 --%> <div class="col-md-4 column"> <a href="${pagecontext.request.contextpath/bookcontroller/bookaddpage" class="btn btn-primary"> 添加 </a> </div> <%-- 返回所有图书 --%> <div class="col-md-4 column"> <a href="${pagecontext.request.contextpath/bookcontroller/queryallbook" class="btn btn-primary"> 返回全部数据 </a> </div> <%-- 根据名称搜索书籍 --%> <div class="col-md-4 column"> <form action="${pagecontext.request.contextpath/bookcontroller/querybookname" method="post" class="form-inline"> <input type="text" name="querybookname" required> <input id="anniu" type="submit" value=" 搜索 "> </form> </div> </div> 配置 Tomcat 并运行! 到目前为止, 这个 SSM 项目整合已经完全的 OK 了, 可以直接运行进行测试! 这个练习十分的重要, 大家需要保证, 不看任何东西, 自己也可以完整的实现出来! 项目结构图 :

125 小结与展望这个是同学们的第一个 SSM 整合案例, 一定要烂熟于心! SSM 框架的重要程度是不言而喻的, 学到这里, 大家已经可以进行基本网站的单独开发 但是这只是增删改查的基本操作 可以说学到这里, 大家才算是真正的步入了后台开发的门 也就是能找一个后台相关工作的底线 或许很多人, 工作就做这些事情, 但是对于个人的提高来说, 还远远不够!