下载文档原格式
请简述mybatis的crud注解及其作用。
MyBatis是一个Java持久层框架，它提供了多种方式来进行数据库的CRUD（增删改查）操作。
除了XML配置文件外，MyBatis还支持使用注解来进行CRUD操作。
在MyBatis中，有以下常用的CRUD注解及其作用：
1.@Select：用于执行查询操作的注解。
可以标注在接口的方法上，
指定SQL语句进行数据查询，并将结果封装到对应的Java对象中。
2.@Insert：用于执行插入操作的注解。
可以标注在接口的方法上，
指定SQL语句将数据插入到数据库表中。
3.@Update：用于执行更新操作的注解。
可以标注在接口的方法上，
指定SQL语句更新数据库表中的数据。
4.@Delete：用于执行删除操作的注解。
可以标注在接口的方法上，
指定SQL语句删除数据库表中的数据。
这些注解可以与SQL语句结合使用，通过在方法上添加相应的注解，可以直接执行对应的数据库操作，避免了手动编写SQL语句和繁琐的结果映射过程。
使用注解的方式可以简化代码，提高开发效率。
请注意的是，使用注解方式进行CRUD操作时，需要在MyBatis的配置文件中启用注解，并配置对应的扫描路径，以便MyBatis能够扫
描到相应的注解。
同时，还需要在接口上添加@Mapper注解或者在配置文件中进行映射配置，以便将接口与对应的SQL语句进行关联。
Mybatis实现数据的增删改查（CRUD）什么是 MyBatis？MyBatis 是支持普通 SQL 查询，存储过程和高级映射的优秀持久层框架。
MyBatis 消除了几乎所有的 JDBC 代码和参数的手工设置以及对结果集的检索。
MyBatis 可以使用简单的XML 或注解用于配置和原始映射，将接口和 Java 的 POJO（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录。
MyBatis下载：https:///mybatis/mybatis-3/releasesMybatis实例对一个User表的CRUD操作：User表：-- ------------------------------ Table structure for `user`-- ----------------------------DROP TABLE IF EXISTS `user`;CREATE TABLE `user` (`id` int(11NOT NULL AUTO_INCREMENT,`userName` varchar(50 DEFAULT NULL,`userAge` int(11 DEFAULT NULL,`userAddress` varchar(200 DEFAULT NULL,PRIMARY KEY (`id`ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;-- ------------------------------ Records of user-- ----------------------------INSERT INTO `user` VALUES ('1', 'summer', '30', 'shanghai';INSERT INTO `user` VALUES ('2', 'test2', '22', 'suzhou';INSERT INTO `user` VALUES ('3', 'test1', '29', 'some place';INSERT INTO `user` VALUES ('4', 'lu', '28', 'some place';INSERT INTO `user` VALUES ('5', 'xiaoxun', '27', 'nanjing';在Src目录下建一个mybatis的xml配置文件Configuration.xmlxml version="1.0" encoding="UTF-8" ?>DOCTYPE configuration PUBLIC "-////DTD Config 3.0//EN" "/dtd/mybatis-3-config.dtd"><configuration><typeAliases><typeAlias alias="User" type="er"/>typeAliases><environments default="development"><environment id="development"><transactionManager type="JDBC"/><dataSource type="POOLED"><property name="driver" value="com.mysql.jdbc.Driver"/><property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis"/><property name="username" value="root"/><property name="password" value="admin"/>dataSource>environment>environments><mappers><mapper resource="com/mybatis/test/User.xml"/>mappers>configuration>定义User mappers的User.xml配置文件xml version="1.0" encoding="UTF-8" ?>DOCTYPE mapper PUBLIC "-////DTD Mapper 3.0//EN""/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.mybatis.test.IUserOperation"><select id="selectUserByID" parameterType="int" resultType="User">select * from `user` where user.id = #{id}select><select id="selectUsersByName" parameterType="string" resultType="User">select * from user where erName = #{userName}select><insert id="addUser" parameterType="User"useGeneratedKeys="true" keyProperty="id">insert into user(userName,userAge,userAddressvalues(#{userName},#{userAge},#{userAddress}insert><update id="updateUser" parameterType="User">update user setuserName=#{userName},userAge=#{userAge},userAddress=#{userAddress} where id=#{id}update><delete id="deleteUser" parameterType="int">delete from user where id=#{id}delete>mapper>配置文件实现了接口和SQL语句的映射关系。
MyBatis整合Spring开发环境：System：WindowsWebBrowser：IE6+、Firefox3+JavaEE Server：tomcat5.0.2.8、tomcat6IDE：eclipse、MyEclipse 8Database：MySQL开发依赖库：JavaEE5、Spring 3.0.5、Mybatis 3.0.4、myBatis-spring-1.0、junit4.8.2Email：hoojo_@Blog：/IBM_hoojo/1、首先新建一个WebProject 命名为MyBatisForSpring，新建项目时，使用JavaEE5的lib库。
然后手动添加需要的jar包，所需jar包如下：2<!-- 设置Spring容器加载配置文件路径 --><context-param><param-name>contextConfigLocation</param-name><param-value>classpath*:applicationContext-*.xml</param-value> </context-param><!-- 配置Spring核心控制器 --><servlet><servlet-name>dispatcher</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServl et</servlet-class><init-param><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/dispatcher.xml</param-value> </init-param><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>dispatcher</servlet-name><url-pattern>*.do</url-pattern></servlet-mapping><!-- 解决工程编码过滤器 --><filter><filter-name>characterEncodingFilter</filter-name><filter-class>org.springframework.web.filter.CharacterEncoding Filter</filter-class><init-param><param-name>encoding</param-name><param-value>UTF-8</param-value></init-param></filter><filter-mapping><filter-name>characterEncodingFilter</filter-name><url-pattern>/*</url-pattern></filter-mapping>3xsi:schemaLocation="/schema/bean s/schema/beans/spring-beans-3.0.x sd/schema/context/schema/context/spring-context-3 .0.xsd"><!-- 注解探测器 --><context:component-scan base-package="com.hoo"/><!-- annotation默认的方法映射适配器 --><bean id="handlerMapping"class="org.springframework.web.servlet.mvc.annotation.DefaultAnnot ationHandlerMapping"/><bean id="handlerAdapter"class="org.springframework.web.servlet.mvc.annotation.AnnotationMe thodHandlerAdapter"/></beans>4、在src目录下添加applicationContext-common.xml，内容如下：<?xml version="1.0"encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/bean s/schema/beans/spring-beans-3.0.x sd/schema/aop/schema/aop/spring-aop-3.0.xsd/schema/tx/schema/tx/spring-tx-3.0.xsd "><!-- 配置DataSource数据源 --><bean id="dataSource"class="org.springframework.jdbc.datasource.DriverManagerDataSource "><property name="driverClassName"value="com.mysql.jdbc.Driver"/><property name="url"value="jdbc:mysql://10.0.0.131:3306/ash2"/><property name="username"value="dev"/><property name="password"value="dev"/></bean><!-- 配置SqlSessionFactoryBean --><bean id="sqlSessionFactory"class="org.mybatis.spring.SqlSessionFactoryBean"><property name="dataSource"ref="dataSource"/><property name="configLocation"value="classpath:mybatis.xml"/><!-- mapper和resultmap配置路径 --><property name="mapperLocations"><list><!-- 表示在com.hoo.resultmap包或以下所有目录中，以-resultmap.xml结尾所有文件 --><value>classpath:com/hoo/resultmap/**/*-resultmap.xml</value> <value>classpath:com/hoo/entity/*-resultmap.xml</value><value>classpath:com/hoo/mapper/**/*-mapper.xml</value></list></property></bean><!-- 单独配置一个Mapper；这种模式就是得给每个mapper接口配置一个bean --> <!--<bean id="accountMapper"class="org.mybatis.spring.mapper.MapperFactoryBean"><property name="mapperInterface"value="com.hoo.mapper.AccountMapper" /><property name="sqlSessionFactory" ref="sqlSessionFactory" /></bean><bean id="companyMapper"class="org.mybatis.spring.mapper.MapperFactoryBean"><property name="mapperInterface"value="panyMapper" /><property name="sqlSessionFactory" ref="sqlSessionFactory" /></bean>--><!-- 通过扫描的模式，扫描目录在com/hoo/mapper目录下，所有的mapper都继承上面的配置最先配置的是DataSource，这里采用的是jdbc的DataSource；然后是SqlSessionFactoryBean，这个配置比较关键。
使用注解实现mybatis的crud操作实验原理随着互联网技术的发展，数据库的应用越来越广泛，其中MyBatis作为一款优秀的持久层框架，在Java开发中占据着重要的地位。
本文将介绍如何使用注解实现MyBatis的CRUD操作实验原理，包括增(insert)、查(select)、改(update)和删(delete)四个部分。
一、注解实现CRUD操作的前提条件首先，我们需要确保项目已经正确地引入了MyBatis的相关依赖，并且已经创建了对应的数据库表。
其次，需要熟悉MyBatis的注解使用方法，包括@Select、@Insert、@Update、@Delete等。
二、注解实现CRUD操作的步骤1.增(insert)：使用@Insert注解实现插入操作。
首先需要编写对应的SQL语句，并将其放在@Insert注解中。
然后，在Java代码中调用MyBatis的SqlSession对象执行该SQL语句即可。
示例代码：```java@Insert("INSERTINTOuser(name,age)VALUES(#{name},#{age})")intinsertUser(Useruser);```2.查(select)：使用@Select注解实现查询操作。
同样需要编写对应的SQL语句，并将其放在@Select注解中。
在Java代码中，可以直接调用SqlSession对象执行该SQL语句，获取查询结果。
示例代码：```javaList<User>userList=sqlSession.selectList("selectUser",use r);```3.改(update)：使用@Update注解实现更新操作。
同样需要编写对应的SQL语句，并将其放在@Update注解中。
在Java代码中，可以使用SqlSession对象执行该SQL语句，更新数据库中的数据。
常见的 crud 操作
常见的 CRUD 操作是指在计算机编程中常用的四种基本数据操作，创建（Create）、读取（Read）、更新（Update）和删除（Delete）。
这些操作是在数据库和应用程序中经常使用的基本操作，用于管理数据和信息。
创建（Create）操作是指向数据库中添加新的数据记录，这可以通过插入新的行或者创建新的文档来实现。
在应用程序中，创建操作可以是用户注册新账户、添加新的产品信息或者创建新的文档等。
读取（Read）操作是指从数据库中检索数据记录，这可以通过查询语句来实现。
在应用程序中，读取操作可以是用户查看个人资料、浏览产品列表或者阅读文章等。
更新（Update）操作是指更新数据库中已有的数据记录，这可以通过修改现有的行或者更新文档来实现。
在应用程序中，更新操作可以是用户修改个人资料、编辑产品信息或者更新文章内容等。
删除（Delete）操作是指从数据库中移除数据记录，这可以通
过删除行或者删除文档来实现。
在应用程序中，删除操作可以是用户注销账户、移除产品信息或者删除文章等。
这四种基本的 CRUD 操作是构建应用程序和管理数据库中数据的基础。
它们为用户提供了管理和操作数据的方式，是编程中不可或缺的重要操作。
通过灵活运用这些操作，开发人员可以构建出功能强大且易于管理的应用程序和数据库系统。
Spring+SpringMVC+Mybatis（SSM）Demo（⼊门详细步骤） 菜鸟⼀枚，刚刚接触Spring不久，前段时间按照⽹上的demo写了下SSM，发现好多都不懂，好不容易程序能运⾏，也能出应有的结果，但想再次安全靠⾃⼰写⼀遍，各个步骤完全记不住，因此发⼀随笔做好记录，⽅便后续查看。
该随笔按我⾃⼰的步骤⼀⼀记录下来，内容包括SpringMVC的配置，以及mybatis generator⾃动⽣成xml配置、entity、dao层等信息。
本⼯程的编辑器⽤的是IDEA，数据库⽤的MySQL。
⼀、新建⼯程1、运⾏IDEA，选择创建⼀个新⼯程，选择maven，创建对应的java web项⽬。
2、填写GroupId和ArtifactId3、配置本地maven仓库（我这⾥已经配置过了，所以显⽰如下）更改maven的本地仓库——更改C:\Users\⽤户名\.m2\setting.xml⽂件（如果没有该⽂件,可以去“idea安装⽬录\plugins\maven\lib\maven3\conf”下复制过来，该⽬录是在安装idea时选择安装maven插件时⾃动⽣成的）中添加<localRepository>本地仓库地址</localRepository>4、填写⼯程名完成⼯程的创建。
5、为了去除spring等框架版本和jdk版本不兼容问题，在settings⾥修改⼯程的jdk版本。
6、更改项⽬结构（图中的xml⽂件都是后续创建的，可以不管）- java 主Java代码⽂件夹 - controller 控制器⽂件⽂件夹 - dao 数据访问层⽂件夹 - service 业务逻辑层⽂件夹 - entity 实体层⽂件夹- resources 资源⽂件夹（要将此定义为Sources Root，不然classpath不会指向该⽬录，卡了本菜鸟好久=_=。
右键选择Mark directory as-->Sources Root-->显⽰） - mapper mybatis sql⽂件夹- webapp web页⾯⽂件夹 -WEB-INF web应⽤的安全⽬录- test 测试⽂件夹⼆、Maven包的初始化1、修改pom.xml配置⽂件相关jar包的⾃动导⼊参考配置如下：1<?xml version="1.0" encoding="UTF-8"?>23<project xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSchema-instance"4 xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd">5<modelVersion>4.0.0</modelVersion>67<groupId>com.mycompany.app</groupId>8<artifactId>Demo</artifactId>9<version>1.0-SNAPSHOT</version>10<packaging>war</packaging>1112<name>Demo Maven Webapp</name>13<!-- FIXME change it to the project's website -->14<url></url>1516<dependencies>17<dependency>18<groupId>junit</groupId>19<artifactId>junit</artifactId>20<version>4.12</version>21<scope>test</scope>22</dependency>23<dependency>24<groupId>org.springframework</groupId>25<artifactId>spring-core</artifactId>26<version>4.3.5.RELEASE</version>27</dependency>28<dependency>29<groupId>org.springframework</groupId>30<artifactId>spring-aop</artifactId>31<version>4.3.5.RELEASE</version>32</dependency>33<dependency>34<groupId>org.springframework</groupId>35<artifactId>spring-orm</artifactId>36<version>4.3.5.RELEASE</version>37</dependency>38<dependency>39<groupId>org.springframework</groupId>40<artifactId>spring-tx</artifactId>41<version>4.3.5.RELEASE</version>42</dependency>43<dependency>44<groupId>org.springframework</groupId>45<artifactId>spring-test</artifactId>46<version>4.3.5.RELEASE</version>47</dependency>48<dependency>49<groupId>org.springframework</groupId>50<artifactId>spring-mock</artifactId>51<version>2.0.8</version>52</dependency>53<dependency>54<groupId>org.springframework</groupId>55<artifactId>spring-jdbc</artifactId>56<version>4.3.5.RELEASE</version>57</dependency>58<dependency>59<groupId>org.springframework</groupId>60<artifactId>spring-context</artifactId>61<version>4.3.5.RELEASE</version>62</dependency>63<dependency>64<groupId>org.springframework</groupId>65<artifactId>spring-context-support</artifactId>66<version>4.3.5.RELEASE</version>67</dependency>68<dependency>69<groupId>org.springframework</groupId>70<artifactId>spring-expression</artifactId>71<version>4.3.5.RELEASE</version>72</dependency>73<!--Spring Web + Spring MVC-->74<dependency>75<groupId>org.springframework</groupId>76<artifactId>spring-web</artifactId>77<version>4.3.1.RELEASE</version>78</dependency>79<dependency>80<groupId>org.springframework</groupId>81<artifactId>spring-webmvc</artifactId>82<version>4.3.1.RELEASE</version>83</dependency>84<dependency>85<groupId>com.github.pagehelper</groupId>86<artifactId>pagehelper</artifactId>87<version>3.7.3</version>88</dependency>89<dependency>90<groupId>com.github.jsqlparser</groupId>91<artifactId>jsqlparser</artifactId>92<version>0.9.1</version>93</dependency>94<!--mysql jdbc-->95<dependency>96<groupId>mysql</groupId>97<artifactId>mysql-connector-java</artifactId>98<version>5.1.38</version>99</dependency>100<!--c3p0-->101<dependency>102<groupId>c3p0</groupId>103<artifactId>c3p0</artifactId>104<version>0.9.1.2</version>105</dependency>106<!--NoClassDefFoundError: javax/servlet/jsp/jstl/core/Config--> 107<!-- https:///artifact/jstl/jstl -->108<dependency>109<groupId>jstl</groupId>110<artifactId>jstl</artifactId>111<version>1.2</version>113<!--file upload jar package-->114<!-- https:///artifact/commons-fileupload/commons-fileupload -->115<dependency>116<groupId>commons-fileupload</groupId>117<artifactId>commons-fileupload</artifactId>118<version>1.3.1</version>119</dependency>120<!-- https:///artifact/commons-io/commons-io -->121<dependency>122<groupId>commons-io</groupId>123<artifactId>commons-io</artifactId>124<version>2.4</version>125</dependency>126<!-- https:///artifact/commons-lang/commons-lang -->127<dependency>128<groupId>commons-lang</groupId>129<artifactId>commons-lang</artifactId>130<version>2.6</version>131</dependency>132<!-- https:///artifact/commons-beanutils/commons-beanutils -->133<dependency>134<groupId>commons-beanutils</groupId>135<artifactId>commons-beanutils</artifactId>136<version>1.8.3</version>137</dependency>138<!-- https:///artifact/commons-collections/commons-collections -->139<dependency>140<groupId>commons-collections</groupId>141<artifactId>commons-collections</artifactId>142<version>3.2.1</version>143</dependency>144<!-- https:///artifact/commons-logging/commons-logging -->145<dependency>146<groupId>commons-logging</groupId>147<artifactId>commons-logging</artifactId>148<version>1.2</version>149</dependency>150<!-- https:///artifact/net.sf.ezmorph/ezmorph -->151<dependency>152<groupId>net.sf.ezmorph</groupId>153<artifactId>ezmorph</artifactId>154<version>1.0.6</version>155</dependency>156<!--json serialize and deserialization-->157<!-- 引⼊fastjson依赖 -->158<dependency>159<groupId>com.alibaba</groupId>160<artifactId>fastjson</artifactId>161<version>1.2.12</version>162</dependency>163<!-- 引⼊gson依赖 -->164<dependency>165<groupId>com.google.code.gson</groupId>166<artifactId>gson</artifactId>167<version>2.6.2</version>168</dependency>169<!--Base64 加解密-->170<!-- https:///artifact/net.iharder/base64 -->171<dependency>172<groupId>net.iharder</groupId>173<artifactId>base64</artifactId>174<version>2.3.8</version>175</dependency>176<!-- https:///artifact/commons-codec/commons-codec -->177<dependency>178<groupId>commons-codec</groupId>179<artifactId>commons-codec</artifactId>180<version>1.10</version>181</dependency>182<!--log4j-->183<!-- https:///artifact/org.apache.logging.log4j/log4j-core -->184<dependency>185<groupId>org.apache.logging.log4j</groupId>186<artifactId>log4j-core</artifactId>187<version>2.6.2</version>188</dependency>189<dependency>190<groupId>org.jetbrains</groupId>191<artifactId>annotations-java5</artifactId>192<version>RELEASE</version>193</dependency>194<!--mybatis 应⽤mybatis需要导⼊mybatis，将mybatis和spring整合在⼀起需要导⼊mybatis-spring--> 195<dependency>196<groupId>org.mybatis</groupId>197<artifactId>mybatis</artifactId>198<version>3.3.0</version>199</dependency>200<dependency>201<groupId>org.mybatis</groupId>202<artifactId>mybatis-spring</artifactId>203<version>1.2.3</version>204</dependency>205<dependency>206<groupId>org.mybatis.generator</groupId>207<artifactId>mybatis-generator-core</artifactId>208<version>1.3.2</version>209</dependency>211212<build>213<finalName>Demo</finalName>214<pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->215<plugins>216<plugin>217<artifactId>maven-clean-plugin</artifactId>218<version>3.0.0</version>219</plugin>220<!-- see /ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->221<plugin>222<artifactId>maven-resources-plugin</artifactId>223<version>3.0.2</version>224</plugin>225<plugin>226<artifactId>maven-compiler-plugin</artifactId>227<version>3.7.0</version>228</plugin>229<plugin>230<artifactId>maven-surefire-plugin</artifactId>231<version>2.20.1</version>232</plugin>233<plugin>234<artifactId>maven-war-plugin</artifactId>235<version>3.2.0</version>236</plugin>237<plugin>238<artifactId>maven-install-plugin</artifactId>239<version>2.5.2</version>240</plugin>241<plugin>242<artifactId>maven-deploy-plugin</artifactId>243<version>2.8.2</version>244</plugin>245</plugins>246</pluginManagement>247</build>248</project>View Code三、SpringMVC的配置1、（⼀般在resource⽂件夹或者WEB-INF⽂件夹）新建spring-servlet.xml⽂件（⽂件名称⼀般为“xxx-servlet.xml”），声明SpringMVC框架对控制器、页⾯、资源的访问。
Spring3 整合MyBatis3 配置多数据源动态选择SqlSessionFactory一、摘要上两篇文章分别介绍了Spring3.3 整合Hibernate3、MyBatis3.2 配置多数据源/动态切换数据源方法和Spring3 整合Hibernate3.5 动态切换SessionFactory （切换数据库方言），这篇文章将介绍Spring整合Mybatis 如何完成SqlSessionFactory的动态切换的。
并且会简单的介绍下MyBatis整合Spring中的官方的相关代码。
Spring整合MyBatis切换SqlSessionFactory有两种方法，第一、继承SqlSessionDaoSupport，重写获取SqlSessionFactory的方法。
第二、继承SqlSessionTemplate 重写getSqlSessionFactory、getConfiguration和SqlSessionInterceptor这个拦截器。
其中最为关键还是继承SqlSessionTemplate 并重写里面的方法。
而Spring整合MyBatis也有两种方式，一种是配置MapperFactoryBean，另一种则是利用MapperScannerConfigurer进行扫描接口或包完成对象的自动创建。
相对来说后者更方便些。
MapperFactoryBean继承了SqlSessionDaoSupport也就是动态切换SqlSessionFactory的第一种方法，我们需要重写和实现SqlSessionDaoSupport方法，或者是继承MapperFactoryBean 来重写覆盖相关方法。
如果利用MapperScannerConfigurer的配置整合来切换SqlSessionFactory，那么我们就需要继承SqlSessionTemplate，重写上面提到的方法。
在整合的配置中很多地方都是可以注入SqlSessionTemplate代替SqlSessionFactory的注入的。
(完整版)SSM三大框架整合详细教程(Spring+SpringMVC+MyBatis) 编辑整理：尊敬的读者朋友们：这里是精品文档编辑中心，本文档内容是由我和我的同事精心编辑整理后发布的，发布之前我们对文中内容进行仔细校对，但是难免会有疏漏的地方，但是任然希望（(完整版)SSM三大框架整合详细教程(Spring+SpringMVC+MyBatis)）的内容能够给您的工作和学习带来便利。
同时也真诚的希望收到您的建议和反馈，这将是我们进步的源泉，前进的动力。
本文可编辑可修改，如果觉得对您有帮助请收藏以便随时查阅，最后祝您生活愉快业绩进步，以下为(完整版)SSM三大框架整合详细教程(Spring+SpringMVC+MyBatis)的全部内容。
(完整版)SSM三大框架整合详细教程（Spring+SpringMVC+MyBatis)编辑整理：张嬗雒老师尊敬的读者朋友们：这里是精品文档编辑中心,本文档内容是由我和我的同事精心编辑整理后发布到文库,发布之前我们对文中内容进行仔细校对,但是难免会有疏漏的地方，但是我们任然希望（完整版）SSM三大框架整合详细教程(Spring+SpringMVC+MyBatis) 这篇文档能够给您的工作和学习带来便利。
同时我们也真诚的希望收到您的建议和反馈到下面的留言区,这将是我们进步的源泉，前进的动力.本文可编辑可修改，如果觉得对您有帮助请下载收藏以便随时查阅，最后祝您生活愉快业绩进步，以下为〈（完整版）SSM三大框架整合详细教程(Spring+SpringMVC+MyBatis）> 这篇文档的全部内容.SSM三大框架整合详细教程（Spring+SpringMVC+MyBatis)使用SSM（Spring、SpringMVC和Mybatis）已经有三个多月了，项目在技术上已经没有什么难点了，基于现有的技术就可以实现想要的功能，当然肯定有很多可以改进的地方。
之前没有记录SSM整合的过程，这次刚刚好基于自己的一个小项目重新搭建了一次，而且比项目搭建的要更好一些。
SpringMVC实现⼀次简单的CRUD⽰例基本环境搭建1、数据库和实体类的名字相同，实体类属性名即数据库字段名。
2、创建实体类对应 dao 类，持久层框架 mybatis 正处于学习中，这⾥就⽤原始的 jdbc 操作了。
3、创建⼀个 java 类，作为 Controller，处理请求。
4、CRUD 涉及到显⽰数据、修改、添加的页⾯；删除就不需要了，修改和添加使⽤同⼀个页⾯。
所以就有 index.jsp(⼀个超链接跳转到 show.jsp)、show.jsp(显⽰所有员⼯信息和操作链接)、input.jsp(⽤于修改和添加)。
具体实现接下来就是 CRUD 的具体实现了，顺序为查询显⽰所有员⼯信息-->删除-->添加-->修改。
在具体的实现前，需要了解⼀下 Controller 类的⼤致结构：package com.taohan.controller;//import *;@Controller@SuppressWarnings("all")public class CURD {@Autowiredprivate DepartmentInfoDao departDao;@Autowiredprivate EmployeeInfoDao empDao;//在后⾯的具体描述中，就只贴出处理对应请求的⽅法代码了}查询①在 index.jsp 页⾯中加⼊下⾯超链接，⽤于获取到所有员⼯集合，保存到域对象中，最后转发(内部跳转) 到 show.jsp 进⾏显⽰。
<a href="emps" rel="external nofollow" >员⼯信息</a>②该请求会交由 Controller 中的指定⽅法处理，下⾯就需要定义处理该请求的⽅法。
//获取所有的员⼯信息@RequestMapping("/emps")public String getemps(Map<String, Object> map) {//获取员⼯集合，存⼊ map 集合中map.put("emps", empDao.getEmployees());return "show";}③现在已经获取到了员⼯集合了，接下来就是编写 show.jsp 页⾯了。
springboot-mybatisplus增删改查CURD操作⼀、注解@TableName(value = "person")//指定表名@TableId(value = "id",type = IdType.AUTO)//指定主键名及⾃增@TableField(value = "name")//指定字段名@TableField(exist = false)//表中不存在的字段⼆、增// modifyNum:返回数据库影响条数Integer modifyNum = personMapper.insert(person);// person.getId()：插⼊完成后，获取插⼊的idSystem.out.println(person.getId());三、删Integer modifyNum = personMapper.deleteById(id);Integer modifyNum = personMapper.deleteBatchIds(idList);Integer modifyNum = personMapper.deleteByMap(personMap);四、改Integer modifyNum = personMapper.updateById(person);五、查Integer id=1;Person person = personMapper.selectById(id);// where id in (?,?)List<Integer> ids=new ArrayList<>();ids.add(1);ids.add(2);List<Person> personList1 = personMapper.selectBatchIds(ids);// where name=? and age=?Map<String, Object> map = new HashMap<>();map.put("name","linlong");map.put("age",27);List<Person> personList2 = personMapper.selectByMap(map);六、WapperPerson person = new Person();person.setName("linlong");// UpdateWrapper<Person> updateWrapper = new UpdateWrapper<>();QueryWrapper<Person> queryWrapper = new QueryWrapper<>();queryWrapper.eq(!StringUtils.isEmpty(person.getName()),"name",person.getName());List<Person> list = personMapper.selectList(queryWrapper);七、⾃定义sqlmybatis-plus:mapper-locations: classpath:mapper/*.xml@Repositorypublic interface PersonMapper extends BaseMapper<Person> {@Select("select * from person")List<Person> findAllPerson();}<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapper PUBLIC "-////DTD Mapper 3.0//EN""/dtd/mybatis-3-mapper.dtd" > <mapper namespace="com.wuxi.dao.PersonMapper"><select id="findAllPerson" resultType="com.wuxi.bean.Person">select * from person</select></mapper>⼋、分页插件@EnableTransactionManagement@Configuration@MapperScan("com.wuxi.dao")public class MybatisPlusCinfig {@Beanpublic PaginationInterceptor paginationInterceptor(){PaginationInterceptor paginationInterceptor = new PaginationInterceptor();return paginationInterceptor;}}@Repositorypublic interface PersonMapper extends BaseMapper<Person> {@Select("select * from person")IPage<Person> findAllPerson(Page<Person> page);//分页对象必须在参数列表第⼀个位置，后⾯是查询条件参数}public void selectPersonPage(){Page<Person> page = new Page<>(1,10);//参数1：查询页码；参数2：每页显⽰数量IPage<Person> iPage = personMapper.findAllPerson(page);System.out.println("当前页码"+iPage.getCurrent());System.out.println("每页显⽰数量"+iPage.getSize());System.out.println("总记录数"+iPage.getTotal());System.out.println("总页数"+iPage.getPages());List<Person> list = iPage.getRecords(); // 数据集合}九、通⽤service/*** Person：bean*/public interface PersonService extends IService<Person> {}/*** PersonMapper：dao* Person：bean*/@Service@Transactionalpublic class PersonServiceImpl extends ServiceImpl<PersonMapper,Person> implements PersonService {}。
·在实现CRUD之前，我想你的开发环境已经搭建好了，我们就不作搭建的说明了，直接进入正题；一般搭建环境都是项目经理的事情，项目经理搭建完环境，就会把环境放到svn服务器上，你只需要从服务器上检出项目环境开发即可；File→Inport→SVN→从SVN检出项目我的资源库已经创建好了，你从视图中打开资源库视图创建一个资源库就好了，选择项目文件夹finish即可；·我们首先要生成简单Java类，也称POJO类，既然有添加hibernate的开发支持，当然要用hibernate提供的功能了,那我们首先编写一个数据库创建脚本，其中包括最常用的字段即可，就编写一个雇员表吧；USE mysql ;DROP TABLE emp ;CREATE TABLE emp(empno INT AUTO_INCREMENT ,ename VARCHAR(30) NOT NULL ,hiredate DATE ,sal VARCHAR(50) NOT NULL ,CONSTRAINT pk_nid PRIMARY KEY(empno)) ;·用hibernate生成一个表的对应的简单java类，打开DB Browser视图→找到对应的表右键→hibernate Reverse Engineering……这个界面就按照下图的设置，下图中没显示的部分，取消勾选，不做设置；·配置完成之后，会生成一个以表名称为类名的一个简单java类，不过首字母大写，采用的annotation注解的方式和数据表配置了映射关系，生成的类会有一些警告，压制一些就OK了，生成的构造方法没有任何用处，删掉即可，一些注释也可以删掉了，另外增加一个toString()方法，这样在做一些异常调试的时候很方便，此类我做了一点简单的注释，可以一看；Emp.javapackage cn.oracle.pojo;import java.util.Date;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;import javax.persistence.Table;import javax.persistence.Temporal;import javax.persistence.TemporalType;@SuppressWarnings("serial")→压制警告用的@Entity→代表这一个实体，与数据表映射对应；@Table(name = "emp", catalog = "mysql")→此设置了这个实体对应的数据库名称和表名称；name 属性是表名称，catalog 是你用到数据库的名字；public class Emp implements java.io.Serializable {private Integer empno;→对应的字段名称；private String ename; →对应的字段名称；private Date hiredate; →对应的字段名称；private String sal; →对应的字段名称；@Id→表示这个字段值主键，唯一的@GeneratedValue→表示此字段自动增长，@Column(name = "empno", unique = true, nullable = false)→对应表中的列的属性，name 表示列名称，unique表示唯一性,nullable表示是否为空；public Integer getEmpno() {return this.empno;}public void setEmpno(Integer empno) {this.empno = empno;}@Column(name = "ename", nullable = false, length = 30)→length表示长度public String getEname() {return this.ename;}public void setEname(String ename) {this.ename = ename;}@Temporal(TemporalType.DATE)→专门标注日期的；@Column(name = "hiredate", length = 10)public Date getHiredate() {return this.hiredate;}public void setHiredate(Date hiredate) {this.hiredate = hiredate;}@Column(name = "sal", nullable = false, length = 50)public String getSal() {return this.sal;}public void setSal(String sal) {this.sal = sal;}@Overridepublic String toString() {return"Emp [empno=" + empno + ", ename=" + ename + ", hiredate="+ hiredate + ", sal=" + sal + "]";}}·简单java类完成是第一步，然后我们需要配置数据库连接了，这是正常的思维模式，也就是最基本的JDBC开发思维模式，但是这一步spring已经在配置的时候已经交给了spring管理了数据库的连接池，只要得到对应的bean就可以得到数据库连接了，也就能操作数据库了；数据库连接类也就相当于spring给我们提供好了，那接下来就是编写接口了，首先编写DAO层接口，DAO(data access Object) 叫做数据访问对象，首先，我们利用泛型编写一个公共的DAO接口，实现基本的CRUD ，当数据表非常多的时候编写此公共的接口很节省代码的；IDAO.javapackage cn.oracle.dao;import java.util.List;public interface IDAO<K,V> {/*** 增加一条数据；* @param vo 简单Java类对象；* @return返回一个boolean对象，增加成功返回true,增加失败返回false;* @throws Exception*/public boolean doCreate(V vo)throws Exception;/*** 更新一条数据；* @param vo 简单Java类对象；* @return返回一个boolean对象，更新成功返回true,更新失败返回false;* @throws Exception*/public boolean doUpdate(V vo)throws Exception;/*** 删除一条数据；* @param id 简单Java类对象的id；* @return返回一个boolean对象，删除成功返回true,删除失败返回false;* @throws Exception*/public boolean doRemove(int id)throws Exception;/*** 查询出一条数据，* @param id 数据对应的id* @return返回一个简单java类对象；* @throws Exception*/public K findById(int id)throws Exception;/*** 查询所有的数据；* @return返回一个简单Java类对象；* @throws Exception*/public List<V> findAll()throws Exception;/*** 模糊查询，也是分页要用的一个方法；* @param column 列名称* @param keyWord 关键字* @param currentPage 当前页* @param lineSize 每页现实的数据条目* @return返回一个List集合；* @throws Exception*/public List<V> findAll(String column,String keyWord,IntegercurrentPage,Integer lineSize)throws Exception;/*** 统计模糊查询的条目* @param column 列名称* @param keyWord 关键字* @return返回一个整数* @throws Exception*/public int getAllCount(String column,String keyWord)throws Exception;}·公共的接口开发完成了，我们接下来就开发IEmpDAO接口，这个接口直接继承IDAO 接口即可，是不是很方便，直接继承即可，如果你需要扩充什么方法的话，直接编写方法即可，package cn.oracle.dao;import cn.oracle.pojo.Emp;public interface IEmpDAO extends IDAO<Integer, Emp> {}·然后当然是编写接口的实现类了，也就是编写方法的具体实现，EmpDAOImpl.javapackage cn.oracle.dao.impl;import java.util.List;import javax.annotation.Resource;import org.hibernate.Criteria;import org.hibernate.Query;import org.hibernate.SessionFactory;import ponent;import cn.oracle.dao.IEmpDAO;import cn.oracle.pojo.Emp;@Component→这个就是Annotation注解，其实你可以理解为在applicationContext.xml文件之中配置了一个bean<bean id=”empDAOImpl” class=”cn.oracle.dao.impl.EmpDAOImpl”>→Component<property name=”sessionFactory” ref=”sessionFactory”/>→Resource</bean>public class EmpDAOImpl implements IEmpDAO {@Resourceprivate SessionFactory sessionFactory;@Overridepublic boolean doCreate(Emp vo) throws Exception {return this.sessionFactory.getCurrentSession().save(vo) != null;}→使用Session接口的save方法来保存数据；@Overridepublic boolean doUpdate(Emp vo) throws Exception {String hql="UPDATE Emp AS e SET e.ename=?,e.hiredate=?,e.sal=? WHERE e.empno=?";Query query=this.sessionFactory.getCurrentSession().createQuery(hql);query.setString(0, vo.getEname());query.setDate(1, vo.getHiredate());query.setString(2, vo.getSal());return query.executeUpdate()>0;}→使用Query实现更新；@Overridepublic boolean doRemove(int id) throws Exception {String hql="DELETE FROM Emp As e WHERE e.empno=?";Query query=this.sessionFactory.getCurrentSession().createQuery(hql);query.setInteger(0, id);return query.executeUpdate()>0;}→使用Query接口实现删除；@Overridepublic Emp findById(int id) throws Exception {return (Emp) this.sessionFactory.getCurrentSession().get(Emp.class, id);}→使用Session接口查询数据；@SuppressWarnings("unchecked")@Overridepublic List<Emp> findAll() throws Exception {Criteriacriteria=this.sessionFactory.getCurrentSession().createCriteria(Emp.class);List<Emp> all=criteria.list();return all;} →使用criteria接口实现全部查询；@SuppressWarnings("unchecked")@Overridepublic List<Emp> findAll(String column, String keyWord,Integer currentPage, Integer lineSize) throws Exception { String hql="FROM Emp AS e WHERE e."+column+" LIKE ?";Query query=this.sessionFactory.getCurrentSession().createQuery(hql);query.setString(0, "%"+keyWord+"%");query.setFirstResult((currentPage-1)*lineSize);query.setMaxResults(lineSize);return (List<Emp>)query.list();}→使用query接口实现分页模糊查询；@Overridepublic int getAllCount(String column, String keyWord) throws Exception { String hql="SELECT COUNT(e.empno) FROM Emp AS e WHERE "+column+" LIKE ?";Query query=this.sessionFactory.getCurrentSession().createQuery(hql);query.setString(0, "%"+keyWord+"%");Integer count=((Long)query.uniqueResult()).intValue();return count;} →使用query接口完成统计；}·编写完成DAO层之后，我们就要做的就是编写服务层了，也就是对DAO层接口的调用，IEmpService.javapackage cn.oracle.service;import java.util.List;import java.util.Map;import cn.oracle.pojo.Emp;public interface IEmpService {public boolean insert(Emp vo)throws Exception;public boolean update(Emp vo)throws Exception;public boolean delete(int id)throws Exception;public Emp get(int id)throws Exception;public List<Emp> list()throws Exception;public Map<String ,Object> list(String column,String keyWord,Integer currentPage,Integer lineSize)throws Exception;}·接口编写完成，之后我们就应该编写实现类了；EmpServiceImpl.javapackage cn.oracle.service.impl;import java.util.HashMap;import java.util.List;import java.util.Map;import javax.annotation.Resource;import org.springframework.stereotype.Service;import cn.oracle.dao.IEmpDAO;import cn.oracle.pojo.Emp;import cn.oracle.service.IEmpService;@Service Service层的专用Annotation注解；public class EmpServiceImpl implements IEmpService {@Resourceprivate IEmpDAO empDAO;@Overridepublic boolean insert(Emp vo) throws Exception {return this.empDAO.doCreate(vo);}@Overridepublic boolean update(Emp vo) throws Exception {return this.empDAO.doUpdate(vo);}@Overridepublic boolean delete(int id) throws Exception {return this.empDAO.doRemove(id);}@Overridepublic Emp get(int id) throws Exception {return this.empDAO.findById(id);}@Overridepublic List<Emp> list() throws Exception {return this.empDAO.findAll();}@Overridepublic Map<String, Object> list(String column, String keyWord,Integer currentPage, Integer lineSize) throws Exception { Map<String ,Object> map=new HashMap<String,Object>();map.put("allEmps", this.empDAO.findAll(column, keyWord, currentPage, lineSize));map.put("allCount", this.empDAO.getAllCount(column, keyWord));return map;}}·到此，后台业务层的增删改查就完成了，然后就是控制器的编写了，我们用的是springmvc的话，自然编写起来很方便的；EmpAction.javapackage cn.oracle.action;import java.util.List;import javax.annotation.Resource;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestMethod;import org.springframework.web.servlet.ModelAndView;import cn.oracle.pojo.Emp;import cn.oracle.service.IEmpService;@Controller→spring mvc的专用annotation注解，代表一个控制器；@RequestMapping("/pages/front/emp/*") →映射路径public class EmpAction {@Resourceprivate IEmpService empService;@RequestMapping(value="emp_list.jsp",method=RequestMethod.GET)public ModelAndView list(HttpServletRequest request,HttpServletResponse response){List<Emp> allEmps=null;try {allEmps=this.empService.list();} catch (Exception e) {e.printStackTrace();}ModelAndView mav=new ModelAndView();mav.setViewName("/pages/front/emp/emp_list.jsp");mav.addObject("allEmps", allEmps);System.out.println(allEmps); 我们就用一个简单的连接做测试，如果后台输出了这些对象的话，说明我们就完成了页面的操作了；return mav;}}如果后台有输出这些信息，说明你的所有配置正常，开发CRUD没任何问题的；。
详解springboot+mybatis-plue实现内置的CRUD使⽤详情mybatis-plus的特性⽆侵⼊：只做增强不做改变，引⼊它不会对现有⼯程产⽣影响，如丝般顺滑损耗⼩：启动即会⾃动注⼊基本CURD，性能基本⽆损耗，直接⾯向对象操作强⼤的 CRUD操作：内置通⽤ Mapper、通⽤Service，仅仅通过少量配置即可实现单表⼤部分 CRUD 操作，更有强⼤的条件构造器，满⾜各类使⽤需求⽀持 Lambda形式调⽤：通过 Lambda 表达式，⽅便的编写各类查询条件，⽆需再担⼼字段写错⽀持主键⾃动⽣成：⽀持多达 4种主键策略（内含分布式唯⼀ ID ⽣成器 - Sequence），可⾃由配置，完美解决主键问题⽀持 ActiveRecord 模式：⽀持ActiveRecord 形式调⽤，实体类只需继承 Model 类即可进⾏强⼤的 CRUD 操作⽀持⾃定义全局通⽤操作：⽀持全局通⽤⽅法注⼊（ Write once, use anywhere ）内置代码⽣成器：采⽤代码或者Maven 插件可快速⽣成 Mapper 、 Model 、 Service 、 Controller层代码，⽀持模板引擎，更有超多⾃定义配置等您来使⽤内置分页插件：基于 MyBatis物理分页，开发者⽆需关⼼具体操作，配置好插件之后，写分页等同于普通 List 查询分页插件⽀持多种数据库：⽀持MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库内置性能分析插件：可输出 Sql 语句以及其执⾏时间，建议开发测试时启⽤该功能，能快速揪出慢查询 - 内置全局拦截插件：提供全表 delete、 update 操作智能分析阻断，也可⾃定义拦截规则，预防误操作⾸先搭建好springboot项⽬，引⼊pom⽂件<!-- mybatis plus 依赖 --><dependency><groupId>com.baomidou</groupId><artifactId>mybatis-plus-boot-starter</artifactId><version>3.1.0</version></dependency><!-- mybatis 依赖 --><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>2.0.1</version></dependency><!-- mybatis 根据实体⽣成数据库表依赖 --><dependency><groupId>com.gitee.sunchenbin.mybatis.actable</groupId><artifactId>mybatis-enhance-actable</artifactId><version>1.1.1.RELEASE</version></dependency>连接数据库这⼀步很关键，这⾥使⽤druid连接mysql数据库<!-- mysql数据库--><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId></dependency><!-- druid连接数据库 --><dependency><groupId>com.alibaba</groupId><artifactId>druid-spring-boot-starter</artifactId><version>1.1.10</version></dependency>application-prod.yml数据源配置⽂件，这⾥使⽤com.mysql.cj.jdbc.Driver的druid数据源，你也可以直接写在application.yml配置⽂件中spring:datasource:url: jdbc:mysql://127.0.0.1:3306/lianxicrud?useUnicode=true&useSSL=false&characterEncoding=utf-8&serverTimezone=Asia/Shanghaiusername: rootpassword: 123456# 使⽤druid数据源type: com.alibaba.druid.pool.DruidDataSourcedriver-class-name: com.mysql.cj.jdbc.Driverserver:port: 8191新建mapper的空⽂件import com.baomidou.mybatisplus.core.mapper.BaseMapper;import er;import org.apache.ibatis.annotations.Mapper;@Mapperpublic interface UserMapper extends BaseMapper<User>{}新建service及impl⽂件Service⽂件继续IServiceImpl继承ServiceImpl<UserMapper,User>实现service抽象接⼝注ServiceImpl查询是直接this.list()，插⼊则使⽤userMapper.insert(user)修改数据删除数据在单独在⽂章内容后⽂补充import com.baomidou.mybatisplus.extension.service.IService;import er;import java.util.List;public interface IUserService extends IService<User>{/*** 查询所有* @return*/List<User> listAll();/*** id条件查询* @return*/User listOne(Long id);* 保存* @param user* @return*/int insert1(User user);}import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;import er;import erMapper;import com.psd.service.IUserService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import java.util.List;import java.util.stream.Collectors;@Servicepublic class UserServiceImpl extends ServiceImpl<UserMapper,User> implements IUserService{ @Autowiredprivate UserMapper userMapper;//查询所有@Overridepublic List<User> listAll() {List<User> users = this.list();return users;}//条件查询public User listOne(Long id) {User user = this.getById(id);return user;}//保存public int insert1(User user){return userMapper.insert(user);}}user实体import com.baomidou.mybatisplus.annotation.TableName;import lombok.Data;@TableName("user")@Datapublic class User{private long id;private String name;private int age;private String email;//..使⽤lombok插件省列get set⽅法}控制器应⽤层类import er;import com.psd.service.IUserService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.*;import java.util.List;@RestControllerpublic class UserController {@Autowiredprivate IUserService userService;@GetMapping("/listAll")public List<User> listAll(){List<User> users = userService.listAll();return users;}@GetMapping("/listOne")public User listOne(){return userService.listOne(1L);}//保存@GetMapping("/save")public void baocun1(int age,String name,String email){User user1 = new User();user1.setAge(age);user1.setName(name);user1.setEmail(email);userService.insert1(user1);}}mybatis-plus修改数据操作@Testpublic void update() {//修改值User user = new User();user.setAge(“20”);user.setName("李四");//修改条件意思就是修改值为user.setAge(“20”);user.setName("李四");像setEmail为null的视为不变，然后条件值为id=1 UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();userUpdateWrapper.eq("id", "1");boolean update = mapper.update(user, userUpdateWrapper);System.out.println(update);}mybatis-plus删除数据操作@Testpublic void delete() {QueryWrapper<User> queryWrapper = new QueryWrapper<>();//条件意思就是删除id=1的并且isNotNull指"id"字段不为空的queryWrapper.ge("id", 1).isNotNull("id");int delete = mapper.delete(queryWrapper);}到此这篇关于详解springboot+mybatis-plue实现内置的CRUD使⽤详情的⽂章就介绍到这了,更多相关springboot+mybatis-plue内置CRUD内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。
SpringMVC基本操作SpringMVC:1.)SpringMVC和Spring的关系：软件开发的三层架构： web层【表⽰层、表现层】---->Service层---->Dao[DataBase Access Object]---->数据库！SpringMVC实际上是Spring的⼀个⼦模块，我们⽤SpringMVC来代替这个JavaWEB部分!MVC:也是⼀种设计模式：M:Model【模型】-->V[View]--->C[Controller]!Model⽤来封装数据的，View:⽤来显⽰数据 Controller：⽤于接收前端页⾯发送的请求，然后调⽤Service层处理，拿到处理结果，将该结果返回给前端页⾯！SpringMVC:相当于MVC架构中的C以及V！以前JavaEE-->现在J2EE2.)SpringMVC有什么优势？Spring 为展现层提供的基于 MVC 设计理念的优秀的Web 框架，是⽬前最主流的 MVC 框架之⼀。
Spring3.0 后全⾯超越 Struts2，成为最优秀的 MVC 框架。
Spring MVC 通过⼀套 MVC 注解，让 POJO 成为处理请求的控制器，⽽⽆须实现任何接⼝。
⽀持 REST 风格的 URL 请求。
GET POST PUT DELTE采⽤了松散耦合可插拔组件结构，⽐其他 MVC 框架更具扩展性和灵活性.⽬前主流的开发软件，说⽩了，⼤家都在⽤！3.)SpingMVC是基于SpingMVC4.x4.)SpringMVC的HelloWorld快速⼊门！1.加⼊JAR包：–commons-logging-1.1.3.jar–spring-aop-4.0.0.RELEASE.jar–spring-beans-4.0.0.RELEASE.jar–spring-context-4.0.0.RELEASE.jar–spring-core-4.0.0.RELEASE.jar–spring-expression-4.0.0.RELEASE.jar–spring-web-4.0.0.RELEASE.jar–spring-webmvc-4.0.0.RELEASE.jar2.配置前端控制器【DispatcherServlet】<!-- The front controller of this Spring Web application, responsible for handling all application requests --><!--向服务器注册前端控制器！ --><servlet><servlet-name>springDispatcherServlet</servlet-name><!--DispatcherServlet指的是SpringMVC的前端控制器！,给服务器使⽤，创建servlet对象！ --><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><!-- 初始化参数contextConfigLocation⽤于指定SpringMVC配置⽂件的路径以及名称 --><init-param><param-name>contextConfigLocation</param-name><param-value>classpath:springmvc.xml</param-value></init-param><!-- 数字0或者⼤于0的数字表⽰的是：在服务器启动的时候创建Servlet对象，⽽不是第⼀次访问的时候创建⼩于0的数字指的是：在第⼀次访问的时候创建Servlet对象.在数字⼤于O的情况下，数字越⼩，优先级越⾼！--><load-on-startup>1</load-on-startup></servlet><!-- Map all requests to the DispatcherServlet for handling --><!-- ⽤ servlet-mapping指定请求映射的路径--><servlet-mapping><servlet-name>springDispatcherServlet</servlet-name><!-- ⽤url-pattern指定拦截的请求路径！ --><url-pattern>/</url-pattern></servlet-mapping>3.创建SpringMVC的配置⽂件并添加要扫描的包注意:1.创建SpringMVC配置⽂件的名字要和上⾯在web.xml⽂件中指定的名字⼀致！2.我们创建SpringMVC配置⽂件的时候使⽤的是Spring Bean Configuration File创建的，不是XML！<!-- 配置SpingMVC容器要扫描的包！ --><context:component-scan base-package="com.neuedu.controller"></context:component-scan>4.在springMVC扫描的包下创建控制器类[Controller/Handler],注意要加⼊@Controller注解/*** 我们通过@RequestMapping做请求URL的映射！* @return*/@RequestMapping("/sayHello")public String sayHello(){return "/WEB-INF/views/success.jsp";}注意：在类的⽅法上我们使⽤的是@RequestMapping，然后在括号⾥指定请求url的请求路径！5.创建页⾯！注意：1.当我们不⽤init-param指定springMVC配置⽂件的路径好位置的时候，SpringMVC默认会去/WEB-INF/<servlet-name>-servlet.xml2.配置视图解析器<!--InternalResourceViewResolvers 是视图解析器，它会将逻辑视图转换成实际的物理视图，做⼀个转发操作！也就是说具体步骤：prefix + ⽅法的返回值 + suffix--><!-- /WEB-INF/views/success.jsp --><bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"><property name="prefix" value="/WEB-INF/views/"></property><property name="suffix" value=".jsp"></property></bean>3.请求⼀个SpringMVC的流程！5.)使⽤ @RequestMapping 映射请求Spring MVC 使⽤ @RequestMapping 注解为控制器指定可以处理哪些 URL 请求在控制器的类定义及⽅法定义处都可标注@RequestMapping– 类定义处：提供初步的请求映射信息。
MyBatis对数据库进⾏CRUD操作1.update修改uodate修改也可以使⽤之前的机制在配置⽂件中直接编写sql但是update语句的set字句中是根据传⼊的值决定的，此时可以通过Mybatis提供的标签实现判断动态拼接update语句：<!-- update修改 --><update id="updateOne">update user<set><if test="name != null">name = #{name},</if><if test="age != 0">age = #{age},</if></set>where id = #{id}</update>测试类：// 根据配置⽂件创建sqlSessionFactoryprivate SqlSessionFactory factory = null;@Beforepublic void before() throws Exception{//1.读取MyBatis核⼼配置⽂件InputStream in = Resources.getResourceAsStream("sqlMapConfig.xml");//2.根据配置⽂件创建sqlSessionFactoryfactory = new SqlSessionFactoryBuilder().build(in);}/*** update操作*/@Testpublic void test07(){User user = new User();user.setId(3);user.setName("sss");user.setAge(12);// 1.创建sqlSessionSqlSession session = factory.openSession();// 2.执⾏操作session.update("erMapper.updateOne",user);// 3.提交事务mit();}2.select查询select查询也可以使⽤之前的机制在配置⽂件中直接编写sql但是select语句的where字句中拼接哪些查询字段是根据传⼊的值决定的此时可以通过MyBatis提供的标签实现判断，动态拼接select语句：<!-- select查询 --><select id="queryMany" resultType="er">select * from user<where><if test="id != 0">id = #{id}</if><if test="name != null">and name = #{name}</if><if test="age != 0">and age = #{age}</if></where></select>测试类：// 根据配置⽂件创建sqlSessionFactoryprivate SqlSessionFactory factory = null;@Beforepublic void before() throws Exception{//1.读取MyBatis核⼼配置⽂件InputStream in = Resources.getResourceAsStream("sqlMapConfig.xml");//2.根据配置⽂件创建sqlSessionFactoryfactory = new SqlSessionFactoryBuilder().build(in);/*** select操作*/@Testpublic void test08(){User user = new User();user.setId(3);user.setName("sss");user.setAge(12);// 1.创建sqlSessionSqlSession session = factory.openSession();// 2.执⾏操作User userx = session.selectOne("erMapper.queryMany",user);// 3.遍历结果System.out.println(userx);} // 根据配置⽂件创建sqlSessionFactoryprivate SqlSessionFactory factory = null;@Beforepublic void before() throws Exception{//1.读取MyBatis核⼼配置⽂件InputStream in = Resources.getResourceAsStream("sqlMapConfig.xml");//2.根据配置⽂件创建sqlSessionFactoryfactory = new SqlSessionFactoryBuilder().build(in);}/*** select操作*/@Testpublic void test08(){User user = new User();user.setId(3);user.setName("sss");user.setAge(12);// 1.创建sqlSessionSqlSession session = factory.openSession();// 2.执⾏操作User userx = session.selectOne("erMapper.queryMany",user);// 3.遍历结果System.out.println(userx);}3.insert操作insert插⼊也可以使⽤之前的机制在配置⽂件中直接编写sql但是insert语句的参数和值的列表拼接哪些字段是根据差u纳⼊的值决定的此时可以通过MyBatis提供的标签实现判断，动态拼接insert语句：<!-- insert操作 --><insert id="insertOne">insert into user<trim prefix="(" suffix=")" suffixOverrides=",">id,<if test="name != null">name,</if><if test="age != 0">age,</if></trim>values<trim prefix="(" suffix=")" suffixOverrides=",">id,<if test="name != null">#{name},</if><if test="age !=0">#{age},</if></trim><!-- insert into user (id,name,age) values (null,#{name},#{age}) --></insert>trim：去掉字符串两端的多余的空格测试类：// 根据配置⽂件创建sqlSessionFactoryprivate SqlSessionFactory factory = null;@Beforepublic void before() throws Exception{//1.读取MyBatis核⼼配置⽂件InputStream in = Resources.getResourceAsStream("sqlMapConfig.xml");//2.根据配置⽂件创建sqlSessionFactoryfactory = new SqlSessionFactoryBuilder().build(in);}* insert操作*/@Testpublic void test09(){User user = new User();user.setName("hhh");user.setAge(33);// 1.创建SqlSessionSqlSession session = factory.openSession();// 2.执⾏操作session.insert("erMapper.insertOne",user);// 3.提交事务mit();}4.delet操作delete删除也可以使⽤之前的机制在配置⽂件中直接编写sql但是delete语句的删除条件、拼接哪些字段，是根据传⼊的值决定的此时可以通过MyBatis提供的标签实现判断，动态拼接delete语句：<!-- delete 操作 --><delete id="deleteOne">delete from user<where><if test="id != 0">id = #{id}</if><if test="name != null">and name = #{name}</if><if test="age != 0">and age = #{age}</if></where></delete><!-- delete 操作2 --><delete id="deleteOne2">delete from user where id in<foreach collection="list" open="(" close=")"separator="," item="id">#{id}</foreach></delete>测试类：// 根据配置⽂件创建sqlSessionFactoryprivate SqlSessionFactory factory = null;@Beforepublic void before() throws Exception{//1.读取MyBatis核⼼配置⽂件InputStream in = Resources.getResourceAsStream("sqlMapConfig.xml");//2.根据配置⽂件创建sqlSessionFactoryfactory = new SqlSessionFactoryBuilder().build(in);}/*** delete操作*/@Testpublic void test10(){User user = new User();user.setId(8);// user.setName("cjj");user.setAge(24);// 1.创建SqlSessionSqlSession session = factory.openSession();// 2.执⾏操作session.insert("erMapper.deleteOne",user);// 3.提交事务mit();}/*** delete操作2*/@Testpublic void test11(){// 0.准备数据List<Integer> list = new ArrayList<Integer>();list.add(3);list.add(6);SqlSession session = factory.openSession();// 2.执⾏操作session.insert("erMapper.deleteOne2",list);// 3.提交事务mit();}。
官网:/p/mybatis/参考资料1 兼顾效率，iBatis一些非见用法(10条)/62575/202886/2 整合Mybatis与Spring3/topic/1018134一环境:XP3+Oracle10g+MyEclipse6+(Tomcat or WebLogic92)+JDK1.5二工程文件: Spring3+MyIbatis3工程图片:jar下载:/topics/download/d209389e-ecac-390e-85c7-c08849f50348三具体代码如下:1 数据库文件create table USERS(id VARCHAR2(50) not null,name VARCHAR2(50),age INTEGER,sex VARCHAR2(1),address VARCHAR2(200),password VARCHAR2(20))insert into users (id,name,age,sex,address,password)VALUES(";123456789";,";sprng";,23,";1";,";北京大学";,";123";);2 Java相关文件A UserMapper.javapackage com.liuzd.ssm.mapper;import java.util.List;import er;public interface UserMapper{public int checkUserExits(User user);public void addUser(User user);public void editUser(User user);public void delUser(String userId);public List<;User>; getUserList();public User getUserByUid(String userId);}B UserMapper.xml文件<;?xml version=";1.0"; encoding=";UTF-8";?>;<;!DOCTYPE mapper PUBLIC ";-////DTD Mapper 3.0//EN"; ";/dtd/mybatis-3-mapper.dtd";>;<;mapper namespace=";erMapper";>;<;resultMap type=";er"; id=";userMap";>; <;id property=";id"; column=";id";/>;<;result property=";name"; column=";name";/>;<;result property=";age"; column=";age";/>;<;result property=";sex"; column=";sex";/>;<;result property=";address"; column=";address";/>;<;result property=";password"; column=";password";/>;<;/resultMap>;<;select id=";checkUserExits"; parameterType=";er"; resultType=";int";>;<;![CDATA[select count(*) from users where name=#{name} and password=#{password} ]]>;<;/select>;<;select id=";getUserList"; resultType=";java.util.List"; resultMap=";userMap";>;<;![CDATA[select * from users]]>;<;/select>;<;select id=";getUserByUid"; parameterType=";string"; resultType=";er";>;<;![CDATA[select * from users where id=#{id}]]>;<;/select>;<;update id=";editUser"; parameterType=";er";>;<;![CDATA[update users set name=#{name},age=#{age},sex=#{sex},address=#{address},password=#{password} where id=#{id}]]>;<;/update>;<;insert id=";addUser"; parameterType=";er";>;<;![CDATA[insert into users (id,name,age,sex,address,password)VALUES(#{id},#{name},#{age},#{sex},#{address}, #{password})]]>;<;/insert>;<;delete id=";delUser"; parameterType=";string";>;<;![CDATA[delete users where id=#{id}]]>;<;/delete>;<;/mapper>;C UserService.javapackage com.liuzd.ssm.service;import java.util.List;import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service;import er;import erMapper;@Service(";userService";)public class UserService {@Autowiredprivate UserMapper userMapper;public void addUser(User user) {erMapper.addUser(user);}public int checkUserExits(User user) {return erMapper.checkUserExits(user);}public void delUser(String userId) {erMapper.delUser(userId);}public User getUserByUid(String userId) {return (User)erMapper.getUserByUid(userId);}public List<;User>; getUserList() {return (List<;User>;)erMapper.getUserList();}public void editUser(User user) {erMapper.editUser(user);}}D WEB层调用代码a LoginController.javapackage com.liuzd.ssm.web;import java.util.List;import javax.annotation.Resource;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import org.springframework.stereotype.Controller;import org.springframework.ui.Model;import org.springframework.web.bind.annotation.ModelAttribute; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.servlet.ModelAndView;import er;import erService;@Controller@RequestMapping(";/login";)public class LoginController {private UserService userService;public UserService getUserService() {return userService;}@Resourcepublic void setUserService(UserService userService) {erService = userService;}@SuppressWarnings(";unchecked";)@RequestMapping(";add";)//@ModelAttribute 可加可不加,url: http://127.0.0.1:8088/ssm/user/add.dopublic String login(User user, HttpServletRequest req, HttpServletResponse response) {// 此处调用服务层进行相应的业务操作// 传递对象于下一页面req.setAttribute(";user";, user);// 调用服务层进行验证用户,此处只演示功能int usize = getUserService().checkUserExits(user);System.out.println(";用户信息: "; + user + ";,usize: ";+usize);if (usize >; 0) {//return ";success";;List<;User>; useralls = this.getUserService().getUserList();req.setAttribute(";userList";, useralls);return ";userList";;}return ";error";;}@SuppressWarnings(";unchecked";)// @RequestMapping(params= ";method=add2";,method=RequestMethod.POST)// 定义method方法不是必须的@RequestMapping(params = ";method=add2";)public ModelAndView login2(@ModelAttribute(";user";)User user, HttpServletRequest req, HttpServletResponse response) {// 使用ModelAndView保存对象于下一页面ModelAndView model = new ModelAndView();model.addObject(";user";, user);// 调用服务层进行验证用户,此处只演示功能int usize = getUserService().checkUserExits(user);System.out.println(";用户信息2: "; + user + ";,usize: ";+usize);if (usize >; 0) {List<;User>; useralls = this.getUserService().getUserList();model.addObject(";userList";, useralls);model.setViewName(";userList";);} else {model.addObject(";msg";,";用户或者密码错误!";);model.setViewName(";error";);}return model;}@RequestMapping(value=";add3/{name}/{password}";,method=RequestMethod.GET) public String login3(@PathVariable(";name";) String name,@PathVariable(";password";) String pwd,Model model) {User user = new User();user.setName(name);user.setPassword(pwd);model.addAttribute(";user";,user);// 调用服务层进行验证用户,此处只演示功能int usize = getUserService().checkUserExits(user);System.out.println(";用户信息3: ";+user + ";,size: "; + usize);if (usize >; 0) {return ";success";;}//放入model默认把参数存于请求model.addAttribute(";msg";,";用户或者密码错误!";);return ";error";;/*** 重定向JSP页面,走出了springmvc配置的view(jsp)* 因为这样说明:model.addAttribute(";msg";,";用户或者密码错误!";);* 获取不到值了* 不加上.jsp就是这样:http://127.0.0.1:8080/Spring3-Login-Annotaction/index?msg=%E7...* *///返回到页面是乱码在页面中用${msg}获取不到值,用request.getParams(";msg";);为乱码//return ";redirect:index.jsp?msg=用户或者密码错误!";;}}b UserController.javapackage com.liuzd.ssm.web;import java.util.List;import javax.annotation.Resource;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.PathVariable;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.SessionAttributes;import org.springframework.web.servlet.ModelAndView;import er;import erService;@Controller@RequestMapping(";/user";)@SessionAttributes(";userList";)public class UserController {private UserService userService;public UserService getUserService() {return userService;}@Resourcepublic void setUserService(UserService userService) {erService = userService;}@RequestMapping(";/userList";)public ModelAndView userList(){/*** 想要在页面展现数据,必须返回ModelAndView类型,返回String是不能获取数据的* */ModelAndView mv = new ModelAndView();List<;User>; users = this.getUserService().getUserList();mv.addObject(";userList";,users);mv.setViewName(";userList";);return mv;}@RequestMapping(";/addUser";)public ModelAndView addUser(User user){System.out.println(";ADD USER: ";+ user);erService.addUser(user);return userList();}@RequestMapping(";/toAddUser";)public String toAddUser(){return ";addUser";;}@RequestMapping(";/delUser/{id}";)public ModelAndView delUser(@PathVariable(";id";) String id){ erService.delUser(id);return userList();}@RequestMapping(";/getUser/{id}";)public ModelAndView getUser(@PathVariable(";id";) String id){ User user = erService.getUserByUid(id);ModelAndView mv = new ModelAndView(";updateUser";);mv.addObject(";user";,user);return mv;}@RequestMapping(";/updateUser";)public ModelAndView editUser(User user){System.out.println(";编辑: ";+user);erService.editUser(user);return userList();}}3 JSp文件A index.jsp<;%@ page language=";java"; pageEncoding=";UTF-8"; contentType=";text/html; charset=UTF-8";%>;<;!DOCTYPE HTML PUBLIC ";-//W3C//DTD HTML 4.01 Transitional//EN";>;<;html>;<;head>;<;%@ include file=";/common/meta.jsp";%>;<;/head>;<;body>;<;form action=";${pageContext.request.contextPath}/login/add.do"; method=";post";>;姓名: <;input type=";text"; name=";name"; id=";name";>;<;br>;密码: <;input type=";password"; name=";password"; id=";password";>;<;br>; <;input type=";submit"; value=";Login";>;<;/form>; <;br>;<;form action=";${pageContext.request.contextPath}/login.do?method=add2"; method=";post";>;姓名: <;input type=";text"; name=";name"; id=";name";>;<;br>;密码: <;input type=";password"; name=";password"; id=";password";>;<;br>; <;input type=";submit"; value=";Login2";>;<;/form>;<;br>;<;ahref=";${pageContext.request.contextPath}/login/add3/spring/spring.do";>;Spring MVC RESL风格<;/a>;<;/body>;<;/html>;B addUser.jsp<;%@ page language=";java"; contentType=";text/html; charset=UTF-8"; pageEncoding=";UTF-8";%>;<;%@ page import=";ng3.RandomStringUtils";%>;<;%String id = RandomStringUtils.randomAlphanumeric(32);%>;<;html>;<;head>;<;title>;用户信息<;/title>;<;/head>;<;body>;<;form action=";${pageContext.request.contextPath}/user/addUser.do"; method=";post";>;<;br>;<;table>;<;tr>;<;td>;<;input name=";id"; type=";hidden"; value=";<;%=id%>;";>;姓名: <;input name=";name";>;<;/td>;<;/tr>;<;tr>;<;td>;年龄: <;input name=";age";>;<;/td>;<;/tr>;<;tr>;<;td>;性别: <;select name=";sex";>;<;option value=";1";>;男<;/option>;<;option value=";2";>;女<;/option>;<;/select>;<;/td>;<;/tr>;<;tr>;<;td>;密码: <;input name=";password";>;<;/td>;<;/tr>;<;tr>;<;td>;地址:<;input name=";address";/>;<;/td>;<;/tr>;<;tr>;<;td align=";right";>;<;input type=";submit"; vlaue=";保存";/>;<;/td>;<;/tr>;<;/table>;<;/form>;<;br>;<;a href=";${pageContext.request.contextPath}/index.jsp";>;返回主页<;/a>;<;br>; <;a href=";${pageContext.request.contextPath}/user/userList.do";>;返回显示<;/a>; <;/body>;<;/html>;C updateUser.jsp<;%@ page language=";java"; contentType=";text/html; charset=UTF-8"; pageEncoding=";UTF-8";%>;<;html>;<;head>;<;title>;编辑用户信息<;/title>;<;/head>;<;body>;<;form action=";${pageContext.request.contextPath}/user/updateUser.do"; method=";post";>;<;br>;<;table>;<;tr>;<;td>;<;input name=";id"; type=";hidden"; value=";${user.id}";>;姓名: <;input name=";name"; value=";${}";>; <;/td>;<;/tr>;<;tr>;<;td>;年龄: <;input name=";age"; value=";${user.age}";>;<;/td>;<;/tr>;<;tr>;<;td>;性别: <;select name=";sex";>;<;option value=";1"; ${user.sex eq ";1"; ? ";selected"; : ";";}>;男<;/option>;<;option value=";2"; ${user.sex eq ";2"; ? ";selected"; : ";";}>;女<;/option>;<;/select>;<;/td>;<;/tr>;<;tr>;<;td>;密码: <;input name=";password"; value=";${user.password}";>;<;/td>;<;/tr>;<;tr>;<;td>;地址:<;input name=";address"; value=";${user.address}";/>;<;/td>;<;/tr>;<;tr>;<;td align=";right";>;<;input type=";submit"; vlaue=";保存";/>;<;/td>;<;/tr>;<;/table>;<;/form>;<;br>;<;a href=";${pageContext.request.contextPath}/index.jsp";>;返回主页<;/a>;<;br>; <;a href=";${pageContext.request.contextPath}/user/userList.do";>;返回集合显示<;/a>;<;/body>;<;/html>;D userList.jsp<;%@ page language=";java"; pageEncoding=";UTF-8"; contentType=";text/html; charset=UTF-8";%>;<;%@ taglib uri=";/WEB-INF/c.tld"; prefix=";c";%>;<;!DOCTYPE HTML PUBLIC ";-//W3C//DTD HTML 4.01 Transitional//EN";>;<;html>;<;head>;<;%@ include file=";/common/meta.jsp";%>;<;/head>;<;body>;<;table width=";60%"; border=";1"; cellpadding=";0"; align=";center";>;<;thead>;<;tr>;<;th style=";cursor: hand;"; title=";按姓名进行排序"; onclick=";sortPage('name')"; valign=";top";>;姓名<;/th>;<;th style=";cursor: hand;"; title=";按年龄进行排序";onclick=";sortPage('age')"; valign=";top";>;年龄<;/th>;<;th style=";cursor: hand;"; title=";按性别进行排序"; onclick=";sortPage('sex')"; valign=";top";>;性别<;/th>;<;th style=";cursor: hand;"; title=";按地址进行排序"; onclick=";sortPage('address')"; valign=";top";>;地址<;/th>;<;th style=";cursor: hand;"; >;操作<;/th>;<;/tr>;<;/thead>;<;tbody>;<;c:forEach items=";${userList}"; var=";user";>;<;tr align=";center";>;<;td>;${}<;/td>;<;td>;${user.age}<;/td>;<;td>;${user.sex eq 1 ? ";男"; : user.sex eq 2 ? ";女"; : ";未知";}<;/td>;<;td>;${user.address}<;/td>;<;td>;<;ahref=";${pageContext.request.contextPath}/user/toAddUser.do";>;添加<;/a>;|<;ahref=";${pageContext.request.contextPath}/user/getUser/${user.id}.do";>;编辑<;/a>;|<;ahref=";${pageContext.request.contextPath}/user/delUser/${user.id}.do";>;删除<;/a>;<;/td>;<;/tr>;<;/c:forEach>;<;/tbody>;<;/table>;<;br>;<;a href=";${pageContext.request.contextPath}/index.jsp";>;返回<;/a>;<;/body>;<;/html>;4 配置文件a web.xml<;?xml version=";1.0"; encoding=";UTF-8";?>;<;web-app version=";2.5"; xmlns=";/xml/ns/javaee";xmlns:xsi=";/2001/XMLSchema-instance";xsi:schemaLocation=";/xml/ns/javaee/xml/ns/javaee/web-app_2_5.xsd";>;<;context-param>;<;param-name>;webAppRootKey<;/param-name>;<;param-value>;ssm.root<;/param-value>;<;/context-param>;<;context-param>;<;param-name>;contextConfigLocation<;/param-name>;<;param-value>;classpath*:applicationContext.xml<;/param-value>;<;/context-param>;<;context-param>;<;param-name>;log4jConfigLocation<;/param-name>;<;param-value>;/WEB-INF/classes/log4j.properties<;/param-value>;<;/context-param>;<;context-param>;<;param-name>;log4jRefreshInterval<;/param-name>;<;param-value>;60000<;/param-value>;<;/context-param>;<;context-param>;<;param-name>;log4jExposeWebAppRoot<;/param-name>;<;param-value>;false<;/param-value>;<;/context-param>;<;listener>;<;listener-class>;org.springframework.web.context.ContextLoaderListener<;/listener-class>;<;/listener>;<;listener>;<;listener-class>;org.springframework.web.util.Log4jConfigListener <;/listener-class>;<;/listener>;<;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>;<;init-param>;<;param-name>;forceEncoding<;/param-name>;<;param-value>;false<;/param-value>;<;/init-param>;<;/filter>;<;filter-mapping>;<;filter-name>;encodingFilter<;/filter-name>;<;url-pattern>;*.do<;/url-pattern>;<;/filter-mapping>;<;filter-mapping>;<;filter-name>;encodingFilter<;/filter-name>;<;url-pattern>;*.jsp<;/url-pattern>;<;/filter-mapping>;<;servlet>;<;servlet-name>;springmvc<;/servlet-name>;<;servlet-class>;org.springframework.web.servlet.DispatcherServlet <;/servlet-class>;<;init-param>;<;param-name>;contextConfigLocation<;/param-name>;<;param-value>;classpath:springmvc.xml<;/param-value>;<;/init-param>;<;load-on-startup>;1<;/load-on-startup>;<;/servlet>;<;servlet-mapping>;<;servlet-name>;springmvc<;/servlet-name>;<;url-pattern>;*.do<;/url-pattern>;<;/servlet-mapping>;<;!-- weblogic配置数据源需要<;resource-ref>;<;description>;s2sh<;/description>;<;res-ref-name>;s2sh<;/res-ref-name>;<;res-type>;javax.sql.DataSource<;/res-type>;<;res-auth>;Container<;/res-auth>;<;/resource-ref>;-->;<;welcome-file-list>;<;welcome-file>;index.jsp<;/welcome-file>;<;/welcome-file-list>;<;/web-app>;b applicationContext.xml<;?xml version=";1.0"; encoding=";UTF-8";?>;<;beans xmlns=";/schema/beans";xmlns:xsi=";/2001/XMLSchema-instance";xmlns:context=";/schema/context";xmlns:aop=";/schema/aop";xmlns:tx=";/schema/tx";xsi:schemaLocation=";/schema/beans/schema/beans/spring-beans-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd /schema/aop/schema/aop/spring-aop-3.0.xsd/schema/tx/schema/tx/spring-tx-3.0.xsd";>;<;context:annotation-config />;<;context:component-scan base-package=";com.liuzd.ssm.service"; />;<;beanclass=";org.springframework.beans.factory.config.PropertyPlaceholderConfigur er";>;<;property name=";locations";>;<;value>;classpath:jdbc.properties<;/value>;<;/property>;<;/bean>;<;bean id=";dataSource"; class=";mons.dbcp.BasicDataSource";destroy-method=";close";>;<;property name=";driverClassName"; value=";${jdbc.driverClassName}";/>;<;property name=";url"; value=";${jdbc.url}"; />;<;property name=";username"; value=";${ername}"; />;<;property name=";password"; value=";${jdbc.password}"; />;<;/bean>;<;!--<;bean id=";dataSource"; class=";org.springframework.jndi.JndiObjectFactoryBean";>;<;property name=";jndiName";>;<;value>;${JNDI}<;/value>;<;/property>;<;property name=";resourceRef";>;<;value>;${RESOURCEREF}<;/value>;<;/property>;<;property name=";jndiEnvironment";>;<;props>;<;propkey=";java.naming.provider.url";>;${Context.PROVIDER_URL}<;/prop>;<;propkey=";java.naming.factory.initial";>;${Context.INITIAL_CONTEXT_FACTORY}<;/prop>;<;/props>;<;/property>;<;/bean>; -->;<;!-- define the SqlSessionFactory, notice that configLocation is not needed when you use MapperFactoryBean -->;<;bean id=";sqlSessionFactory"; class=";org.mybatis.spring.SqlSessionFactoryBean";>;<;property name=";dataSource"; ref=";dataSource"; />;<;!--<;property name=";configLocation"; value=";classpath*:mybatis-config.xml";/>;-->;<;/bean>;<;!-- scan for mappers and let them be autowired -->;<;bean class=";org.mybatis.spring.mapper.MapperScannerConfigurer";>;<;property name=";basePackage"; value=";com.liuzd.ssm.mapper"; />;<;/bean>;<;/beans>;。
