devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SSM框架SpringMVC+ Spring + MyBatis介绍_后端:ssm框架(spring+springmvc+mybatis)

作者：不正经 | 2024-02-07 22:31:09

赞

踩

后端:ssm框架(spring+springmvc+mybatis)

1.ssm介绍

1.1.spring

①Spring是一个开源框架

②Spring为简化企业级开发而生，使用Spring开发可以将Bean对象，Dao组件对象，Service组件对象等交给Spring容器来管理，这样使得很多复杂的代码在Spring中开发却变得非常的优雅和简洁，有效的降低代码的耦合度，极大的方便项目的后期维护、升级和扩展。

③Spring是一个IOC(DI)和AOP容器框架。

④Spring的优良特性

[1]非侵入式：基于Spring开发的应用中的对象可以不依赖于Spring的API

[2]控制反转：IOC——Inversion of Control，指的是将对象的创建权交给Spring去创建。使用Spring之前，对象的创建都是由我们自己在代码中new创建。而使用Spring之后。对象的创建都是由给了Spring框架。

[3]依赖注入：DI——Dependency Injection，是指依赖的对象不需要手动调用setXX方法去设置，而是通过配置赋值。

[4]面向切面编程：Aspect Oriented Programming——AOP

[5]容器：Spring是一个容器，因为它包含并且管理应用对象的生命周期

[6]组件化：Spring实现了使用简单的组件配置组合成一个复杂的应用。在 Spring 中可以使用XML和Java注解组合这些对象。

[7]一站式：在IOC和AOP的基础上可以整合各种企业应用的开源框架和优秀的第三方类库（实际上Spring 自身也提供了表述层的SpringMVC和持久层的Spring JDBC）

Spring框架分为四大模块：
Core核心模块。负责管理组件的Bean对象

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-aop-4.0.0.RELEASE.jar

spring-aspects-4.0.0.RELEASE.jar

数据库操作

spring-jdbc-4.0.0.RELEASE.jar

spring-orm-4.0.0.RELEASE.jar

spring-oxm-4.0.0.RELEASE.jar

spring-tx-4.0.0.RELEASE.jar

spring-jms-4.0.0.RELEASE.jar

Web模块

spring-web-4.0.0.RELEASE.jar

spring-webmvc-4.0.0.RELEASE.jar

spring-websocket-4.0.0.RELEASE.jar

spring-webmvc-portlet-4.0.0.RELEASE.jar

1.2.SpringMVC

1.2.1.SpringMVC的简介

SpringMVC是一种基于Spring实现了Web MVC设计模式的请求驱动类型的轻量级Web框架，使用了MVC的架构模式思想，将Web层进行指责解耦，并管理应用所需的生命周期，为简化日常开发，提供了很大便利。

SpringMVC提供了总开关DispatcherServlet;请求处理映射器（Handler Mapping）和处理适配器（Handler Adapter），视图解析器（View Resolver）进行视图管理;动作处理器Controller接口（包含ModelAndView，以及处理请求响应对象请求和响应），配置灵活，支持文件上传，数据简单转化等强大功能。

View:视图层：为用户提供UI，重点关注数据的呈现。

Model：模型层：业务数据的信息表示，关注支撑业务的信息构成，通常是多个业务实体的组合。

Controller：控制器：调用业务逻辑产生合适的数据（Model）传递数据给视图层用于呈现。

1.2.2.SpringMVC的常用注解标签

1.@Controller   用于标记在一个类上，使用它标记的类就是一个SpringMVC Controller对象。分发处理器将会扫描使用了该注解的类的方法，并检测该方法是否使用了@RequestMapping注解。@ Controller只是定义了一个控制器类，而使用@RequestMapping注解的方法才是真正处理请求的处理器。单个使用@Controller标记在一个类上还不能真正意义上的说它就是SpringMVC的一个控制器类，因为这个时候Spring还不认识它。那么要如何做Spring才能认识它呢？这个时候就需要我们把这个控制器类交给Spring来管理。有两种方式：（1）在SpringMVC的配置文件中定义MyController的bean对象。（2）在SpringMVC的配置文件中告诉Spring该到哪里去找标记为@Controller的Controller控制器。

  1.  
  2. <!--方式一-->
  3. <bean class="com.host.app.web.controller.MyController"/>
  4. <!--方式二-->
  5. < context:component-scan base-package = "com.host.app.web" />//路径写到controller的上一层(扫描包详解见下面浅析)

2.@RequestMapping     RequestMapping是一个用来处理请求地址映射的注解，可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。

3.@Resource和@Autowired      @Resource和@Autowired都是做bean的注入时使用，其实@Resource并不是Spring的注解，它的包是javax.annotation.Resource，需要导入，但是Spring支持该注解的注入。
4.@ModelAttribute和@SessionAttributes     该控制器的所有方法在调用前，先执行此@ModelAttribute方法，可用于注解和方法参数中，可以把这个@ModelAttribute特性，应用在BaseController当中，所有的控制器继承BaseController，即可实现在调用Controller时，先执行@ModelAttribute方法。@ SessionAttributes即将值放到session作用域中，写在类上面。
5.@PathVariable       用于将请求URL中的模板变量映射到功能处理方法的参数上，即取出URI模板中的变量作为参数。

  1. @Controller  
  2. public class TestController {  
  3.      @RequestMapping(value="/user/{userId}/roles/{roleId}",method = RequestMethod.GET)  
  4.      public String getLogin(@PathVariable("userId") String userId,  
  5.          @PathVariable("roleId") String roleId){  
  6.          System.out.println("User Id : " + userId);  
  7.          System.out.println("Role Id : " + roleId);  
  8.          return "hello";  
  9.      }  
  10.      @RequestMapping(value="/product/{productId}",method = RequestMethod.GET)  
  11.      public String getProduct(@PathVariable("productId") String productId){  
  12.            System.out.println("Product Id : " + productId);  
  13.            return "hello";  
  14.      }  
  15.      @RequestMapping(value="/javabeat/{regexp1:[a-z-]+}",  
  16.            method = RequestMethod.GET)  
  17.      public String getRegExp(@PathVariable("regexp1") String regexp1){  
  18.            System.out.println("URI Part 1 : " + regexp1);  
  19.            return "hello";  
  20.      }  
  21. }

6.@ReauestParam      主要用于在SpringMVC后台控制层获取参数，类似一种是request.getParameter（“name”），它有三个常用参数：defaultValue =“0”，required = false，value =“isApp”; defaultValue表示设置默认值，required铜过布尔设置是否是必须要传入的参数，值值表示接受的传入的参数类型。
7.@ResponseBody     该注解用于将控制器的方法返回的对象，通过适当的HttpMessageConverter转换为指定格式后，写入到响应对象的身体数据区。使用时机：返回的数据不是html标签的页面，而是其他某种格式的数据时（如JSON，XML等）使用;
8.@Component      相当于通用的注解，当不知道一些类归到哪个层时使用，但是不建议。
9.@Repository       用于注解道层，在daoImpl类上面注解。

10.@Service       用于注解业务层，在serviceImpl类上面注解。

1.2.3.SpringMVC的工作流程与介绍

（1）客户端通过URL发送请求

（2-3）核心控制器Dispatcher Servlet接收到请求，通过系统或自定义的映射器配置找到对应的处理程序，并将url映射的控制器控制器返回给核心控制器。

（4）通过核心控制器找到系统或默认的适配器

（5-7）由找到的适配器，调用实现对应接口的处理器，并将结果返回给适配器，结果中包含数据模型和视图对象，再由适配器返回给核心控制器

（8-9）核心控制器将获取的数据和视图结合的对象传递给视图解析器，获取解析得到的结果，并由视图解析器响应给核心控制器

（10）核心控制器将结果返回给客户端
 

1.3.Mybatis

1.3.1.什么是Mybatis

这里借用官网的一句话介绍什么是mybatis：MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。


1.3.2.Mybatis相对JDBC有哪些优势

  1.         public static void main(String[] args) {
  2. 			Connection connection = null;
  3. 			PreparedStatement preparedStatement = null;
  4. 			ResultSet resultSet = null;
  5. 			
  6. 			try {
  7. 				//1、加载数据库驱动
  8. 				Class.forName("com.mysql.jdbc.Driver");
  9. 				//2、通过驱动管理类获取数据库链接
  10. 				connection =  DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis", "root", "root");
  11. 				//3、定义sql语句 ?表示占位符
  12. 			        String sql = "select * from user where username = ?";
  13. 				//4、获取预处理statement
  14. 				preparedStatement = connection.prepareStatement(sql);
  15. 				//5、设置参数，第一个参数为sql语句中参数的序号（从1开始），第二个参数为设置的参数值
  16. 				preparedStatement.setString(1, "王五");
  17. 				//6、向数据库发出sql执行查询，查询出结果集
  18. 				resultSet =  preparedStatement.executeQuery();
  19. 				//7、遍历查询结果集
  20. 				while(resultSet.next()){
  21. 					User user 
  22. 					System.out.println(resultSet.getString("id")+"  "+resultSet.getString("username"));
  23. 				}
  24. 			} catch (Exception e) {
  25. 				e.printStackTrace();
  26. 			}finally{
  27. 				//8、释放资源
  28. 				if(resultSet!=null){
  29. 					try {
  30. 						resultSet.close();//释放结果集
  31. 					} catch (SQLException e) {
  32. 						// TODO Auto-generated catch block
  33. 						e.printStackTrace();
  34. 					}
  35. 				}
  36. 				if(preparedStatement!=null){
  37. 					try {
  38. 						preparedStatement.close();
  39. 					} catch (SQLException e) {
  40. 						// TODO Auto-generated catch block
  41. 						e.printStackTrace();
  42. 					}
  43. 				}
  44. 				if(connection!=null){
  45. 					try {
  46. 						connection.close();//关闭数据库连接
  47. 					} catch (SQLException e) {
  48. 						// TODO Auto-generated catch block
  49. 						e.printStackTrace();
  50. 					}
  51. 				}
  52.  
  53. 			}
  54.  
  55. 		}

通过上面的一段jdbc连接数据代码，我们看有哪些不好的地方：

1.在创建connection的时候，存在硬编码问题（也就是直接把连接信息写死，不方便后期维护）

2.preparedStatement对象在执行sql语句的时候存在硬编码问题。

3.每次在进行一次数据库连接后都会关闭数据库连接，频繁的开启/关闭数据连接影响性能。

简单的说一下mybatis相对jdbc的优势：

1.mybatis是把连接数据库的信息都是写在配置文件中，因此不存在硬编码问题，方便后期维护。

2.mybatis执行的sql语句都是通过配置文件进行配置，不需要写在java代码中。

3.mybatis的连接池管理、缓存管理等让连接数据库和查询数据效率更高。

......
————————————————
1.3.3.Mybatis框架的原理介绍

 

1.3.4.Mybatis全局配置文件

SqlMapConfig.xml是Mybatis的全局配置文件，它的名称可以是任意，但是一般命名都为（SqlMapConfig）

1.3.4.1.全局配置文件的类容和顺序
Properties(属性)

Settings（全局参数设置）

typeAliases（类型别名）

typeHandlers（类型处理器）

objectFactory（对象工厂）

plugins（插件）

environments（环境信息集合）

environment（单个环境信息）

transactionManager（事物）

dataSource（数据源）

mappers（映射器）
1.3.4.2.常见配置详解

一.properties标签：

Mybatis可以通过该标签来读取java配置信息：

例如在工程中对数据源信息写在db.properties文件中，可以通过properties标签来加载该文件。

db.properties:

  1. db.driver=com.mysql.jdbc.Driver
  2. db.url=jdbc:mysql://localhost:3306/mybatis
  3. db.username=root
  4. db.password=123456

SqlMapConfig.xml使用properties标签：

  1. <!-- 通过properties标签，读取java配置文件的内容 -->
  2. <properties resource="db.properties" />
  3.  
  4. <!-- 配置mybatis的环境信息 -->
  5. <environments default="development">
  6. 	<environment id="development">
  7. 		<!-- 配置JDBC事务控制，由mybatis进行管理 -->
  8. 		<transactionManager type="JDBC"></transactionManager>
  9. 		<!-- 配置数据源，采用dbcp连接池 -->
  10. 		<dataSource type="POOLED">
  11. 			<property name="driver" value="${db.driver}"/>
  12. 			<property name="url" value="${db.url}"/>
  13. 			<property name="username" value="${db.username}"/>
  14. 			<property name="password" value="${db.password}"/>
  15. 		</dataSource>
  16. 	</environment>
  17. </environments>

注意：

1、 先加载properties中property标签声明的属性

因此在property中的name属性的值和value比properties中的resource属性先加载。后加载的db.properties会覆盖于property加载属性和值。

<properties resource="db.properties">

    <property name="db.username",value="1234"/>

</properties>  

2、 再加载properties标签引入的java配置文件中的属性

3、 parameterType的值会和properties的属性值发生冲突。因此，在properties文件里的内容命名最好加上db.代表是跟数据源相关的属性，这样就不容易跟以后的属性发生冲突。
二.settings标签：

该标签是mybatis的全局设置，该设置会影响mybatis的运行。一般我们使用使用该标签来开启二级缓存和懒加载。

三.typeAliases标签

该标签是对po类进行别名设置，这样，在后面使用po类的时候就可以直接通过别名引用，而不需要通过po类的全限定名来引用。这样可以提高我们的开发效率。

首先介绍下Mybatis的默认提供的别名有：

自定义单个别名：这种方式只能定义单个类的别名。

下面的代码就是把com.cxb.mybatis.po.User类定义为user的别名

  1.     <typeAliases>
  2. 		<!-- 设置单个别名 -->
  3. 		<typeAlias type="com.cxb.mybatis.po.User" alias="user"/>
  4. 	</typeAliases>

自定义之批量定义别名：

下面代码是把com.cxb.mybatis.po类下的所有类都声明别名，默认的别名就是类名（类名大小写都可以）

  1.     <!-- 设置别名 -->
  2. 	<typeAliases>
  3. 		<!-- 批量设置别名 -->
  4. 		<!-- package:指定包名称来为该包下的po类声明别名，默认的别名就是类名（类名首字母大小写都可以） -->
  5. 		<package name="com.cxb.mybatis.po"/>
  6. 	</typeAliases>

四.mappers标签

该标签的作用是加载映射文件

方式一：<mapper resource=""/>

该方式是加载相对于类路径下的映射文件：

  1. <mappers>
  2.    <mapper resource="sqlmap/User.xml"/>
  3. </mappers>

方式二：<mapper url=""/>

该方式使用全限定路径：

<mapper url="file:///D:\spingmvc\mybatis\config\sqlmap\User.xml" />

方式三：<mapper class=""/>

该方式使用mapper接口的全限定类名：

<mapper class="com.cxb.mapper.UserMapper"/>

此方式要求：

    Mapper接口Mapper映射文件名称相同且在同一个目录下。

方式四：<package name=""/>

    该方式是加载指定包下的所有映射文件:

<package name="com.cxb.mybatis.mapper"/>

此方式要求：

    Mapper接口Mapper映射文件名称相同且在同一个目录下。

五.映射文件

第一种：简单类型

#{}表示占位符?，parameterType接收简单类型的参数时，里面的名称可以任意

  1.     <select id="findUserById" parameterType="java.lang.Integer" resultType="user">
  2. 		SELECT * FROM USER WHERE id = #{id}
  3. 	</select>

${}表示拼接符，parameterType接收简单类型的参数时，里面的名称必须是value

  1.     <select id="findUsersByName" parameterType="java.lang.String" resultType="com.cxb.mybatis.po.User">
  2. 		SELECT * FROM USER WHERE username LIKE "%${value}%"
  3. 	</select>

第二种：pojo类型

这里通过用户的用户名进行模糊查询演示pojo类型

在映射文件中添加模糊查询语句：

  1. <!-- parameterType传递pojo类型 -->
  2. 	<select id="findUsersByPojo" parameterType="com.lc.mybatis.po.User" resultType="com.cxb.mybatis.po.User">
  3. 		SELECT  * FROM USER WHERE username LIKE "%${username}%"
  4. 	</select>

user类:

  1. public class User {
  2. 	private Integer id;
  3. 	private String username;
  4. 	private Date birthday;
  5. 	private String sex;
  6. 	private String address;
  7. }

测试：

  1. public class UserDao{
  2. //根据用户名进行模糊查询
  3.         @Override
  4.         public List<User> findUserByPojo(){ 
  5.             //全局配置文件路径：
  6.              String resource = "SqlMapConfig.xml";
  7.              InputStream inputStream = Resources.getResourceAsStream(resource);
  8.              //创建SqlSessionFactory
  9.              SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  10.              SqlSession sqlSession = sqlSessionFactory.openSession();
  11.              User user = new User();
  12.              user.setUsetname("张三");
  13.              List<User> users = (List<User>)sqlSession.selectList("test.findUsersByPojo",user);//传入pojo
  14.              System.out.println(users);
  15.              sqlSession.close();
  16.              return users;
  17.         }
  18. }

第三种：使用包装类型pojo

  1. public class UserVO {
  2. 	private User user;
  3.  
  4. 	public User getUser() {
  5. 		return user;
  6. 	}
  7.  
  8. 	public void setUser(User user) {
  9. 		this.user = user;
  10. 	}
  11. 	
  12. }
  1. <!-- parameterType传递pojo包装类型 -->
  2. 	<select id="findUsersByPojo1" parameterType="com.cxb.mybatis.po.UserVO" resultType="user"> 
  3. 		SELECT * FROM USER WHERE username LIKE "%${user.username}%" AND address=#{user.address}
  4. 	</select>

测试：

  1. public class UserDao{
  2. //根据用户名和地址进行查询
  3.         @Override
  4.         public List<User> findUserByPojo1(){
  5.                 //全局配置文件路径：
  6.                 String resource = "SqlMapConfig.xml";
  7.                 InputStream inputStream = Resources.getResourceAsStream(resource);
  8.                 //创建SqlSessionFactory
  9.                 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  10.                 SqlSession sqlSession = sqlSessionFactory.openSession();
  11.                 User user = new User();
  12.                 user.setUsetname("小石潭记");
  13.                 user.setAddress("重庆市忠县");
  14.                 UserVO userVo = new UserVO();
  15.                 userVo.setUser(user);
  16.                 List<User> users = (List<User>)sqlSession.selectList("test.findUsersByPojo1",userVo);//传入pojo包装类
  17.                 System.out.println(users);
  18.                 sqlSession.close();
  19.                 return users;
  20.         }
  21.  
  22. }

第四种：map集合类型

  1. <!-- parameterType传递hashmap类型 -->
  2. 	<select id="findUsersByMap" parameterType="java.util.Map" resultType="user">
  3. 		SELECT * FROM USER WHERE username LIKE "%${username}%" AND address=#{address}
  4. 	</select>
  1. public class UserDao{
  2. //根据用户名和地址进行查询
  3.         @Override
  4.         public List<User> findUserByMap(){
  5.                 //全局配置文件路径：
  6.                 String resource = "SqlMapConfig.xml";
  7.                 InputStream inputStream = Resources.getResourceAsStream(resource);
  8.                 //创建SqlSessionFactory
  9.                 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  10.                 SqlSession sqlSession = sqlSessionFactory.openSession();
  11.                 Map<String,String> map = new HashMap<>();
  12.                 map.put("username","小石潭记");
  13.                 map.put("address","重庆市忠县");
  14.                 List<User> users = (List<User>) sqlSession.selectList("test.findUsersByMap",map);//传入pojo包装类
  15.                 System.out.println(users);
  16.                 sqlSession.close();
  17.                 return users;
  18.         }
  19.  
  20. }

六.resultMap结果映射

  1. <!-- 如果查询出来的列名有别名就不能通过resultType来接收输出类型了。需要通过resultMap来声明传出类型（resultMap需要声明） -->
  2. 	<resultMap type="user" id="userMap">
  3. 		<!-- id标签：专门查询结果中唯一列映射 -->
  4. 		<id column="id_" property="id"/>
  5. 		<!-- result标签：映射查询结果中的普通列 -->
  6. 		<result column="username_" property="username"/>
  7. 		<result column="address_" property="address"/>
  8. 	</resultMap>
  9. 	<select id="findUserResultMap" parameterType="int" resultMap="userMap">
  10. 		select id id_,username username_,address address_ from user where id=#{id}
  11. 	</select>
  1. public class UserDao{
  2.         @Override
  3.         public User findUserResultMap(){
  4.                 //全局配置文件路径：
  5.                 String resource = "SqlMapConfig.xml";
  6.                 InputStream inputStream = Resources.getResourceAsStream(resource);
  7.                 //创建SqlSessionFactory
  8.                 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  9.                 SqlSession sqlSession = sqlSessionFactory.openSession();
  10.                 User user = sqlSession.selectOne("test.findUserResultMap",1);
  11.                 System.out.println(user);
  12.                 sqlSession.close();
  13.                 return user;
  14.         }
  15.  
  16. }

七.动态sql

  1. <!-- 定义sql片段，用于可重用的sql片段 -->
  2. 	<sql id="whereClause">
  3. 		<!-- if标签：可以对输入的参数进行判断 -->
  4. 		<!-- test:指定判断表达式 -->
  5. 		<if test="user!=null">
  6. 			<if test="user.username!=null and user.username!=''">
  7. 				AND username LIKE '%${user.username}%'
  8. 			</if>
  9. 			<if test="user.address!=null and user.address!=''">
  10. 				AND address=#{user.address}
  11. 			</if>
  12. 		</if>
  13. 		<if test="idList!=null">
  14. 			AND id IN
  15. 			<!-- foreach标签： 可以循环传入参数值 -->
  16. 			<!-- collenction：标示pojo中集合属性的属性名称 -->
  17. 			<!-- item:每次遍历出来的对象 -->
  18.                         <!--open开始遍历时拼接的串-->
  19.                         <!--close结束遍历时拼接的串-->
  20.                         <!--separator遍历每个对象之间需要拼接字符-->
  21.                         <foreach collection="idList" item="item" open="(" close=")" separator=",">
  22. 				#{item}
  23. 			</foreach>
  24. 		</if>
  25. 	</sql>
  26. 	
  27. 	<select id="findUserList" parameterType="userVO" resultType="user">
  28. 		SELECT * FROM USER
  29. 		<!-- where标签： 默认去掉第一个AND，如果没有参数就去掉where自己-->
  30.                 <where>
  31.                     <!--引用sql语句片段-->
  32.                      <include refid="whereClause"></include>
  33. 		</where>
  34. 	</select>

userVo类：

  1. public class UserVO {
  2. 	private User user;
  3. 	private List<Integer> idList;
  4. 	
  5.  
  6. 	public List<Integer> getIdList() {
  7. 		return idList;
  8. 	}
  9.  
  10. 	public void setIdList(List<Integer> idList) {
  11. 		this.idList = idList;
  12. 	}
  13.  
  14. 	public User getUser() {
  15. 		return user;
  16. 	}
  17.  
  18. 	public void setUser(User user) {
  19. 		this.user = user;
  20. 	}
  21. 	
  22. }

测试：

  1. public class UserDao{
  2.         @Override
  3.         public void findUserList(){
  4.                 //全局配置文件路径：
  5.                 String resource = "SqlMapConfig.xml";
  6.                 InputStream inputStream = Resources.getResourceAsStream(resource);
  7.                 //创建SqlSessionFactory
  8.                 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  9.                 SqlSession sqlSession = sqlSessionFactory.openSession();
  10.                 //测试foreach语句执行
  11.                 UserVO userVo = new UserVO();
  12.                 List<Integer> idList = new ArrayList<>();
  13.                 idList.add(1);
  14.                 idList.add(2);
  15.                 idList.add(3);
  16.                 userVo.setIdList(idList);
  17.                 //测试select * from user where username like ? and address=?;
  18.                 //User user = new User();
  19.                 //user.setUsername("张三");
  20.                 //user.setAddress("武当山");
  21.                 //userVo.setUser(user);
  22.                 List<User> users = sqlSession.selectOne("test.findUserList",userVo);
  23.                 System.out.println(users);
  24.                 sqlSession.close(); 
  25.         }
  26.  
  27. }

SSM框架SpringMVC+ Spring + MyBatis实现

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/67834
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号