第一节课 第一个mybatis应用程序
1、新建一个java项目为：mybatis_0921, 项目结构：
2、代码
User.java
private String username,userid; //懂我意思啊？
配置文件：mybatis-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<environments default="development">
<environment id="development">
<!-- 数据库的驱动管理类型 -->
<transactionManager type="JDBC" />
<!-- 配置数据源 -->
<dataSource type="POOLED">
<property name="url" value="jdbc:mysql://localhost:3306/user"/>
<property name="username" value="root"/>
<property name="password" value="caixibei"/>
<property name="driver" value="com.mysql.jdbc.Driver"/>
</dataSource>
</environment>
</environments>
<!-- 配置映射文件 -->
<mappers>
<mapper resource="/src/mybatis-usermapper.xml" />
</mappers>
</configuration>
配置文件:mybatis-usermapper.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper>
<!-- 1、查询用户 -->
<select id="queryUsers" resultType="my.entity.User">
select * from userinfo;
</select>
</mapper>
3、数据库的创建
mysql> use user;
Database changed
mysql> select * from userinfo;
+----------+----------+
| username | userid |
+----------+----------+
| wsz | a123 |
| wsz | a123 |
| wsz | a123 |
| wsz | a123 |
| wsz | a123 |
| wsz | a123 |
| wsz | a123 |
| asda | a1dasd23 |
| asda | a1dasd23 |
| asda | a1dasd23 |
| asda | a1dasd23 |
+----------+----------+
11 rows in set (0.00 sec)
mysql>
4、然后编写测试代码:
1、实现所有用户的查询操作
package my.test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
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 my.entity.User;
public class Test {
public static void main(String[] args) throws IOException {
//1、加载mybatis核心配置文件
InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
//2、通过核心配置文件创建会话工厂
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
//3、通过会话工厂打开会话
SqlSession sqlSession = sqlSessionFactory.openSession();
//4、通过会话实现数据库的查询操作
//*1--查询所有学生
queryUsers(sqlSession);
}
//查询所有学生操作
public static void queryUsers(SqlSession sqlSession) {
List<User> list = sqlSession.selectList("userOperate.queryUsers");
System.out.println("学生信息如下：");
for(User user:list) {
System.out.println(user);
}
}
}
5、效果
6、实现单个用户的条件查询
1)配置文件：mybatis-usermapper.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="userOperate">
<!-- 1、查询用户 -->
<select id="queryUsers" resultType="my.entity.User">
select * from userinfo;
</select>
<!-- 2、条件查询用户 -->
<select id="queryUser" resultType="my.entity.User">
select * from userinfo where userid=#{userid};
</select>
</mapper>
2）测试代码:Test.java
package my.test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
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 my.entity.User;
public class Test {
public static void main(String[] args) throws IOException {
//1、加载mybatis核心配置文件
InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
//2、通过核心配置文件创建会话工厂
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
//3、通过会话工厂打开会话
SqlSession sqlSession = sqlSessionFactory.openSession();
//4、通过会话实现数据库的查询操作
//*1--查询所有用户
queryUsers(sqlSession);
//*2--条件查询某个用户
queryUser(sqlSession);
}
//查询所有学生操作
public static void queryUsers(SqlSession sqlSession) {
List<User> list = sqlSession.selectList("userOperate.queryUsers");
System.out.println("学生信息如下：");
for(User user:list) {
System.out.println(user);
}
}
//条件查询用户
public static void queryUser(SqlSession sqlSession) {
User user = sqlSession.selectOne("userOperate.queryUser","0000");
System.out.println("查询用户id为'0000'的用户信息如下：");
System.out.println(user);
}
}
7、效果
8、根据条件删除指定的用户信息
1)测试代码Test.java
package my.test;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
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 my.entity.User;
public class Test {
public static void main(String[] args) throws IOException {
//1、加载mybatis核心配置文件
InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
//2、通过核心配置文件创建会话工厂
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
//3、通过会话工厂打开会话
SqlSession sqlSession = sqlSessionFactory.openSession();
//4、通过会话实现数据库的查询操作
//*1--查询所有用户
queryUsers(sqlSession);
//*2--条件查询某个用户
queryUser(sqlSession);
//*3--根据id删除用户信息
deleteUser(sqlSession);
//5、提交事务：如果不提交，后台数据库并不会发生改变
sqlSession.commit();
//6、关闭事务
sqlSession.close();
}
//查询所有学生操作
public static void queryUsers(SqlSession sqlSession) {
List<User> list = sqlSession.selectList("userOperate.queryUsers");
System.out.println("学生信息如下：");
for(User user:list) {
System.out.println(user);
}
}
//条件查询用户
public static void queryUser(SqlSession sqlSession) {
User user = sqlSession.selectOne("userOperate.queryUser","0000");
System.out.println("查询用户id为'0000'的用户信息如下：");
System.out.println(user);
}
//删除用户信息
public static void deleteUser(SqlSession sqlSession) {
sqlSession.delete("userOperate.deleteUser","0000");
System.out.println("删除成功...");
}
}
2）配置文件mybatis-usermapper.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="userOperate">
<!-- 1、查询用户 -->
<select id="queryUsers" resultType="my.entity.User">
select * from userinfo;
</select>
<!-- 2、条件查询用户 -->
<select id="queryUser" resultType="my.entity.User">
select * from userinfo where userid=#{userid};
</select>
<!-- 3、根据userid对指定的用户进行信息的删除 -->
<delete id="deleteUser">
delete from userinfo where userid=#{userid};
</delete>
</mapper>
9、效果：
第二节课 使用接口注解实现数据库的操作
1、新建一个java项目，项目结构如下：
2、数据库，我们依旧使用上节课用的数据库：user.sql
--表：userinfo
--记录如下：
mysql> use user;
Database changed
mysql> select * from userinfo;
+----------+----------+
| username | userid |
+----------+----------+
| wsz | a123 |
| wsz | a123 |
| wsz | a123 |
| wsz | a123 |
| wsz | a123 |
| wsz | a123 |
| wsz | a123 |
| asda | a1dasd23 |
| asda | a1dasd23 |
| asda | a1dasd23 |
| asda | a1dasd23 |
+----------+----------+
11 rows in set (0.00 sec)
3、代码
核心配置文件：mybatis-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC" />
<dataSource type="POOLED">
<property name="url" value="jdbc:mysql://localhost:3306/user"/>
<property name="username" value="root"/>
<property name="password" value="caixibei"/>
<property name="driver" value="com.mysql.jdbc.Driver"/>
</dataSource>
</environment>
</environments>
</configuration>
dao层数据库持久化操作接口：UserDao.java
1）实现所有用户的信息查询操作
package my.dao;
import java.util.List;
import org.apache.ibatis.annotations.Select;
import my.entity.User;
public interface UserDao {
//*--1、查询所有用户
@Select("select * from userinfo")
public List<User> queryUsers();
}
测试代码: Test_01.java
package my.test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
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 org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import my.dao.UserDao;
import my.entity.User;
public class Test_01 {
static UserDao userDao = null;
static SqlSession sqlSession = null;
@BeforeAll
public static void getMapper() throws IOException {
//--1)加载mybatis核心配置文件
InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
//--2)根据核心配置文件创建会话工厂并且添加映射
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
sqlSessionFactory.getConfiguration().addMapper(UserDao.class);
//--3)通过会话工厂获取会话并得到接口
sqlSession = sqlSessionFactory.openSession();
userDao = sqlSession.getMapper(UserDao.class);
//--4)操作数据库
}
//*--1、查询所有用户信息
@Test
public void queryUsers() {
List<User> list = userDao.queryUsers();
for(User user:list) {
System.out.println(user);
}
}
//*--2、根据id修改某一个用户的信息
@Test
public void updateUser() {
userDao.updateUser("baby", "2017120107", "a123");
System.out.println("修改成功...");
}
//提交并关闭事务
@AfterAll
public static void commit() {
sqlSession.commit();
sqlSession.close();
}
}
效果
2）根据id修改某一个用户的信息
测试代码：Test_01.java
package my.dao;
import java.util.List;
import org.apache.ibatis.annotations.Select;
import my.entity.User;
public interface UserDao {
//*--1、查询所有用户
@Select("select * from userinfo")
public List<User> queryUsers();
}
测试代码: Test_01.java
package my.test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
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 org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import my.dao.UserDao;
import my.entity.User;
public class Test_01 {
static UserDao userDao = null;
static SqlSession sqlSession = null;
@BeforeAll
public static void getMapper() throws IOException {
//--1)加载mybatis核心配置文件
InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
//--2)根据核心配置文件创建会话工厂并且添加映射
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
sqlSessionFactory.getConfiguration().addMapper(UserDao.class);
//--3)通过会话工厂获取会话并得到接口
sqlSession = sqlSessionFactory.openSession();
userDao = sqlSession.getMapper(UserDao.class);
//--4)操作数据库
}
//*--1、查询所有用户信息
@Test
public void queryUsers() {
List<User> list = userDao.queryUsers();
for(User user:list) {
System.out.println(user);
}
}
//*--2、根据id修改某一个用户的信息
@Test
public void updateUser() {
userDao.updateUser("baby", "2017120107", "a123");
System.out.println("修改成功...");
}
//提交并关闭事务
@AfterAll
public static void commit() {
sqlSession.commit();
sqlSession.close();
}
}
dao层接口
package my.dao;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
import my.entity.User;
public interface UserDao {
//*--1、查询所有用户
@Select("select * from userinfo")
public List<User> queryUsers();
//*--2、根据id修改某一个用户的信息
@Update("update userinfo set username=#{username},userid=#{newid} where userid=#{userid}")
public void updateUser(@Param("username")String username,@Param("newid")String newid,@Param("userid")String userid);
}
效果:
关于其他操作数据库的方法，请自行编写代码测试…
第三节课 Mybatis表关联（一对多）
1、首先我们需要两个数据库的表
数据库：db_user
表1： tb_userinfo
表2： tb_postinfo
mysql> select * from tb_userinfo;
+----------+--------+
| username | userid |
+----------+--------+
| caixibei | 001 |
| caixibei | 002 |
+----------+--------+
2 rows in set (0.00 sec)
mysql> select * from tb_postinfo;
+----------+--------+--------+
| postname | postid | userid |
+----------+--------+--------+
| t1 | 001 | 001 |
| t2 | 002 | 002 |
| t3 | 003 | 002 |
| t4 | 004 | 003 |
| t1 | 001 | 001 |
| t2 | 002 | 002 |
+----------+--------+--------+
6 rows in set (0.00 sec)
一个用户对应多个帖子
2、新建一个java项目：mybatis_0927
3、代码
1)两个实体类对应两张表
//User.java
private String username,userid;
private List<Post> posts;
//Post.java
private String postname,postid ;
private User user;
2)配置文件的编写：mybatis-config.xml && mybatis-usermapper.xml && db.properties
<!--mybatis-config.xml-->
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<properties resource="db.properties"/>
<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 resource="mybatis-tb_usermapper.xml"/>
</mappers>
</configuration>
<!--mybatis-tb_usermapper.xml-->
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="operateTb_userinfo">
<select id="selectUsers" resultType="my.entity.User">
select * from tb_userinfo;
</select>
<select id="selectUserById" resultMap="selectUserMap">
select tb_userinfo.*,tb_postinfo.* from tb_postinfo,tb_userinfo
where tb_userinfo.userid=tb_postinfo.userid
and tb_userinfo.userid=#{userid};
</select>
<resultMap type="my.entity.User" id="selectUserMap">
<result property="username" column="username" />
<result property="userid" column="userid" />
<collection property="postlist" ofType="my.entity.Posts" >
<result property="postname" column="postname"/>
<result property="postid" column="postid"/>
<result property="userid" column="userid"/>
</collection>
</resultMap>
</mapper>
//参数配置文件
url=jdbc:mysql://127.0.0.1:3306/db_user
username=root
password=caixibei
driver=com.mysql.jdbc.Driver
i.分析
ii.关于resultMap标签：
部分元素结构：
<resultMap type="" id="">
<result /> 注入到字段或javaBean属性的普通结果
<collection /> 用于一对多关联
<id /> 用于表示哪一个是主键
<association> 用于一对一关联
</resultMap>
4)日志机制
1、我们添加下面两个jar包完成日志机制
a. log4j-1.2.17.jar
b. commons-logging-1.2.jar
2、日志机制的配置文件
### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=D:\mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
### set log levels - for more verbose logging change 'info' to 'debug' ###
### fatal error warn info debug trace
log4j.rootLogger=debug, stdout
4)测试代码
package my.test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
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 my.entity.User;
public class Test01 {
public static void main(String[] args) throws IOException {
InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
List<User> list = sqlSession.selectList("operateTb_userinfo.selectUserById","002");
for(User user:list) {
System.out.println(user);
}
}
}
4、测试
第四节课 Mybatis表关联（一对一）
1、我们在上一节课的项目基础上mybatis_1002
2、使用Mapper代理
注意事项：
Mapper接口开发需要遵循以下规范：
1、 Mapper.xml文件中的namespace与mapper接口的类路径相同。
2、 Mapper接口方法名和Mapper.xml中定义的每个statement的id相同
3、 Mapper接口方法的输入参数类型和mapper.xml中定义的每个sql 的parameterType的类型相同
4、 Mapper接口方法的输出参数类型和mapper.xml中定义的每个sql的resultType的类型相同
ps:每个用户只能拥有一个身份证信息,所以用户和身份信息是一对一的关系，也就是说 用户(User)-身份证号(IdCard)（一对一）
3、代码
1)数据库文件从今天开始，我们就不再使用mysql进行操作了，我们全部统一使用oracle数据库吧！
--oracle数据库连接参数
username=system
password=caixibei
url=jdbc:oracle:thin:@127.0.0.1:1521:user
driver=oracle.jdbc.OracleDriver
编码展示：
//1、User.java
private String username,userid;
private Card card;
//2、Card.java
private String cardid,code;
//3、UserDao.java
package my.dao;
import my.entity.User;
public interface UserDao {
//提供一个查询的方法
public User selectUserById(String userid);
}
//4、CardDao.java
package my.dao;
import my.entity.Card;
public interface CardDao {
public Card selectCardById(String userid);
}
//5、TestClass.java
package my.test;
import java.io.IOException;
import java.io.InputStream;
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 my.dao.UserDao;
import my.entity.User;
public class TestClass {
public static void main(String[] args) throws IOException {
//1、加载数据库核心配置文件
InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
//2、创建工厂
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
//3、创建会话
SqlSession sqlSession = sqlSessionFactory.openSession();
//4、获取Mapper接口映射
UserDao userDao = sqlSession.getMapper(UserDao.class);
//5、执行数据库的操作
User user = userDao.selectUserById("006");
//6、打印输出
System.out.println(user);
}
}
配置文件
<!--mybatis-config.xml-->
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- 数据库源文件参数映射 -->
<properties resource="db.properties" />
<!-- 配置数据库的源数据 -->
<environments default="development">
<environment id="development">
<transactionManager type="JDBC" />
<dataSource type="POOLED">
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
<property name="url" value="${url}"/>
<property name="driver" value="${driver}"/>
</dataSource>
</environment>
</environments>
<!-- 操作某个数据库文件映射 -->
<mappers>
<!-- 表：tb_userinfo -->
<mapper resource="usermapper.xml"/>
<mapper resource="cardmapper.xml"/>
</mappers>
</configuration>
<!--usermapper.xml-->
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="my.dao.UserDao">
<!-- 查询用户信息+用户的博文+身份 -->
<select id="selectUserById" resultMap="userMap">
select * from userinfo where userid=#{userid}
</select>
<resultMap type="my.entity.User" id="userMap">
<result property="username" column="username"/>
<result property="userid" column="userid"/>
<!-- 一对一 -->
<association property="card" column="cardid" select="my.dao.CardDao.selectCardById"/>
</resultMap>
</mapper>
<!--cardmapper.xml-->
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="my.dao.CardDao">
<select id="selectCardById" resultType="my.entity.Card">
select * from cardinfo where cardid=#{cardid}
</select>
</mapper>
4、效果
今天，我们继续打点鸡血，把动态SQL的其他操作稍微带过一下,至于具体的代码操作请各位自行编写总结经验！
1、<if/> 判断语句，用于单一条件分支判断
2、<choose>(<when/> <otherwise>)相当于java中的switch...case...default语句，用于多分支判断
3、<where>、<trim>、<set>辅助元素，用于字符串的SQL拼装、特殊字符问题
4、<bind> 从OGNL表达式中创建一个变量，并将其绑定到上下文，常用于模糊查询的sql中
第五节课 动态SQL语句
1、基本操作，还是新建一个Web项目吧：mybatis_1003
2、我们看下数据库user里面的表记录，方便我们后期的操作
3、代码
我们看到这里有三个列，且他的列标题是
username
userid
cardid
所以我们需要新建一个与表userinfo对应的实例类
package my.entity;
public class User {
//设置属性
private String username,userid,cardid;
//无参构造+带参构造
public User() {
super();
}
public User(String username, String userid, String cardid) {
super();
this.username = username;
this.userid = userid;
this.cardid = cardid;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getUserid() {
return userid;
}
public void setUserid(String userid) {
this.userid = userid;
}
public String getCardid() {
return cardid;
}
public void setCardid(String cardid) {
this.cardid = cardid;
}
@Override
public String toString() {
return "User [username=" + username + ", userid=" + userid + ", cardid=" + cardid + "]";
}
}
然后，对应的我们需要写好数据库的配置文件
参数配置：db.properties
url=jdbc:oracle:thin:@127.0.0.1:1521:user
username=system
password=caixibei
driver=oracle.jdbc.OracleDriver
然后，我们需要写mybatis的全局配置文件：mybatis-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- 加载参数配置文件db.properties -->
<properties resource="/config/db.properties"/>
<!-- 配置数据源 -->
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
<property name="url" value="${url}"/>
<property name="driver" value="${driver}"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="/config/usermapper.xml" />
</mappers>
</configuration>
然后，我们需要表的sql映射文件：usermapper.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="my.dao.UserDao">
<!-- 1、查询 -->
<select id="selectUserByIdOrName" resultType="my.entity.User">
select * from userinfo where 1=1
<choose>
<!-- 都非空 -->
<when test="userid!=null and username!=''">
and userid like #{userid}||'%' and username like #{username}||'%'
</when>
<!-- username为空，就只需要查userid -->
<when test="username==null or username==''">
and userid like #{userid}||'%' and username like #{username}||'%'
</when>
<!-- userid为空，就只需要查username -->
<when test="userid==null or userid==''">
and username like #{username}||'%' and userid like '%'||#{userid}||'%'
</when>
</choose>
</select>
</mapper>
然后，我们需要dao层接口完成代理操作：UserDao
package my.dao;
import org.apache.ibatis.annotations.Param;
import my.entity.User;
public interface UserDao {
//根据userid+username修改信息
public List<User> selectUserByIdOrName(@Param("username")String username,@Param("userid")String userid);
}
最后，我们需要一个servlet服务类去调用操作接口的方法实现数据库的操作
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
request.setCharacterEncoding("UTF-8");
response.setContentType("text/html;charset=utf-8");
//接受页面传来的值
String username = request.getParameter("username");
String userid = request.getParameter("userid");
//加载核心配置文件
InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
//通过核心配置文件创建会话工厂
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
//通过工厂打开会话
SqlSession sqlSession = sqlSessionFactory.openSession();
UserDao userDao = sqlSession.getMapper(UserDao.class);
//调用查询方法
List<User> list = userDao.selectUserByIdOrName(username, userid);
//打印输出
System.out.println(list==null);
if(list==null) {
System.out.println("查无此人");
}
for(User user:list) {
System.out.println(user);
}
}
4、运行效果
1）输入全为空的时候，默认查询所有：
2) 当只输入userid的时候，查询userid匹配的
5、关于更多的动态SQL操作，请自行前往学习…
第五节课 逆向工程
第六节课 第一个Spring应用程序
1、导包、基本的jar包就这六个
commons-logging-1.2.jar
spring-aop-4.3.18.RELEASE.jar
spring-beans-4.3.18.RELEASE.jar
spring-context-4.3.18.RELEASE.jar
spring-core-4.3.18.RELEASE.jar
spring-expression-4.3.18.RELEASE.jar
2、我们都知道spring的两大特性：IOC控制反转、DI依赖注入，所以我们需要SpringIOC容器上下文配置文件applicationContext.xml
applicationContext.xml上下文配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 通过setter\getter进行依赖注入，这种方式的依赖注入基于实例类的setter和getter方法 -->
<bean id="t_01" class="my.entity.Student">
<property name="t_name" value="蔡熙贝" />
<property name="t_id" value="2017120107"/>
<property name="t_gender" value="男" />
</bean>
<!-- 通过构造器进行依赖注入，这种构造方法依赖实例类的构造方法 -->
<bean id="t_02" class="my.entity.Student">
<constructor-arg value="王安石" />
<constructor-arg value="2014010322"/>
<constructor-arg value="男" />
</bean>
<!-- 通过p命名空间进行依赖注入 -->
<bean id="t_03" class="my.entity.Student" p:t_name="李小白" p:t_id="2017128282" p:t_gender="男" />
</beans>
实例类Student.java
private String t_name;
private String t_id;
private String t_gender;
Test.java
package my.test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import my.entity.Student;
public class Test {
public static void main(String[] args) {
//测试
test();
}
public static void test() {
//加载spring ioc全局配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//获取bean
Student student1 = (Student)context.getBean("t_01");
Student student2 = (Student)context.getBean("t_02");
Student student3 = (Student)context.getBean("t_03");
//输出bean
System.out.println(student1);
System.out.println(student2);
System.out.println(student3);
}
}
分析
运行效果：
第七节课 对象构造的三种方法
第一种：通过默认的构造方法进行获取
该方法不再另行做过多讲解…
第二种：通过静态工厂获取对象
新建静态工厂
package server;
import entity.Student;
public class StudentDao {
public static Student getStudent() {
return new Student();
}
}
学生实例对象
private String name;
private String gender;
private int age;
配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 采用静态工厂的方法获取Bean对象 -->
<bean id="student" class="server.StudentDao" factory-method="getStudent"></bean>
</beans>
分析
测试类
package test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import entity.Student;
public class Test {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
Student student = (Student)context.getBean("student");
student.setName("才西北");
System.out.println(student);
}
}
第三种：通过实例工厂构造对象
配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 采用实例工厂的方法获取Bean对象 -->
<!-- 工厂 -->
<bean id="studentFactory" class="server.StudentDao" />
<!-- 通过工厂调用得到实例Student -->
<bean id="student" factory-bean="studentFactory" factory-method="getStudent" />
</beans>
分析
第八节课 spring之面向切面编程AOP
1、AOP的相关名词
2、AOP的通知类型
3、通过XML文件进行AOP通知
1）前置通知
配置文件
前置通知方法
业务类
测试方法
2)后置通知
配置文件
业务类
3)环绕通知请自行测试
声明：环绕通知的接口invoke()方法会对调用的业务类方法进行拦截！
4、通过注解进行AOP通知
1)前置通知
配置文件
前置通知
业务类
测试
2)后置通知
自行编写
第*节课 第一个Spring MVC应用程序
1、为甚么要使用Spring MVC框架？
2、现在我们开始我们的第一个Spring mvc应用程序，构建一个动态项目如下：
3、然后我们需要配置web.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0">
<display-name>springmvc_1024</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<!-- 1、配置Spring IOC容器的监听器 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value></param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- 2、配置前端过滤器 -->
<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<!-- 3、配置页面的编码过滤器 -->
<filter>
<filter-name>encoding</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>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encoding</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
PS:编码过滤器是根据甚么写的？
打开jar包的资源文件，你会发现他的构造方法中的两个属性：String encoding ,boolean forceEncoding
因为我还没有新建spring ioc容器的文件，故而上述web.xml文件中没有指定容器的位置
4、编写dispatcher-servlet.xml控制器文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 视图解析器 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 配置前缀 -->
<property name="prefix" value="/jsp/" />
<!-- 配置后缀 -->
<property name="suffix" value=".jsp"/>
</bean>
<bean id="helloWorldController" class="com.xixijiazi.controller.HelloWorldController"/>
</beans>
5、控制器
package com.xixijiazi.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
@Controller
public class HelloWorldController{
@RequestMapping(value = "/jsp/index.do")
public ModelAndView index() {
return new ModelAndView("index","message","HelloWorld!");
}
}
6、补充
7、项目完整路径
8、总结：spring mvc 好骚啊！！！
第*节课 Spring MVC表单处理
1、新建web项目如下：
2、需求：模拟用户登录，登陆成功后跳转到获取用户登录的信息页面
3、我们需要新建页面：
//首页index.jsp
<body>
<h3>欢迎来到熙熙佳榟电子书城，点击登录<a href="/springmvc_1025/login.action">登录 & 注册</a></h3>
</body>
首页预览：
//用户登录页面：login.jsp
<body>
请在下面填写表格完成登录信息的注册：
<%-- <form action="/loginBack.action" method="post">
姓名：<input type="text" name="username"/>
年龄:<input type="number" name="age"/>
登录名：<input type="text" name="loginname"/>
密码:<input type="password" name="password"/>
</form> --%>
<form:form action="/springmvc_1025/loginBack.action" commandName="user">
姓名：<form:input path="username"/>
年龄：<form:input path="age"/>
登录名：<form:input path="loginname"/>
密码：<form:password path="password"/>
<input type="submit" value="提交">
</form:form>
</body>
登录界面预览：
//登录成功页面：success.jsp
<body>
${user }
</body>
界面预览：
4、页面写好了，我们需要配置好spring ioc的配置文件以及mvc的配置文件
//web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0">
<display-name>springmvc_1025</display-name>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.jsp</welcome-file>
<welcome-file>default.html</welcome-file>
<welcome-file>default.htm</welcome-file>
<welcome-file>default.jsp</welcome-file>
</welcome-file-list>
<!-- 配置spring ioc容器的监听器 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- 配置前端过滤器 -->
<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<!-- 配置编码过滤器 -->
<filter>
<filter-name>encoding</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>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encoding</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
//dispatcher-servlet.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
<context:component-scan base-package="xixijiazi.controller"/>
<!-- 视图解析器 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/jsp/" />
<property name="suffix" value=".jsp" />
</bean>
</beans>
//applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
<context:component-scan base-package="xixijiazi.entity"/>
</beans>
5、然后我们就需要写好控制器
package xixijiazi.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import xixijiazi.entity.User;
@Controller
public class LoginController {
@Autowired
@Qualifier("user")
private User user;
//创建入口的Model
@ModelAttribute("user")
public User getUser() {
return user;
}
//跳转到登陆界面进行登录
@RequestMapping("/login.action")
public String login() {
return "login";
}
//跳转到登录成功页面或者重新登录
@RequestMapping("/loginBack.action")
public String loginBack(User user,Model model) {
model.addAttribute("user",user);
return "success";
}
}
6、运行效果上面已经展示过了
Spring MVC之文件上传
前言: 经过前面的学习，我们学习了很多关于Spring MVC表单的事项，现在我们模拟做一个文件上传的网站。
1、创建一个动态Web项目：Xftp
2、
Spring 整合Mybatis
1、创建项目：ssm
2、我们都知道在mybatis中，也能操作数据库（增删改查），spring同样也可以实现
但是如果需要整合在一起又是如何去整合的呢？
3、项目结构：
4、整合的步骤
1）导入相关的jar包
2）配置数据库的参数文件db.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/cxb?useUnicode=true&characterEncoding=utf-8
jdbc.username=root
jdbc.password=caixibei
3)配置spring ioc上下文配置文件
<!-- 1、加载参数文件db.properties -->
<context:property-placeholder location="classpath:db.properties"/>
<!-- 2、配置数据源：使用c3p0数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="jdbcUrl" value="${jdbc.url}"/>
<property name="driverClass" value="${jdbc.driver}"/>
<property name="user" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
<!--
在Mybatis中我们需要的是一个mybatis-config.xml的文件配置好数据源
，获取SqlSession对象操作数据库
-->
<!-- 3、加载SqlSessionFactoryBean对象 -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<!-- 配置mybatis核心配置文件 -->
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<!-- 加载数据源 -->
<property name="dataSource" ref="dataSource"/>
<!-- 加载mapper映射文件 -->
<property name="mapperLocations" value="classpath:student-mapper.xml"/>
</bean>
<!-- 4、获取SqlSession对象：SqlSessionTemplate是一个安全线程对象，每一次运行都会获取一个新的SqlSession对象 -->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>
4)配置springmvc的相关配置
1.在web.xml文件中配置前端页面控制器
<!-- 配置spring ioc文件的监听器 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- 配置前端页面控制器 -->
<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<!-- 配置编码过滤器 -->
<filter>
<filter-name>encoding</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>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encoding</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
2.在dispatcher-servlet.xml文件中配置视图解析器
<!-- 配置控制器 -->
<context:component-scan base-package="my.controller"/>
<!-- 配置视图解析器 -->
<bean id="resourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/jsp/" />
<property name="suffix" value=".jsp" />
</bean>
3、在student-mapper.xml文件中编写操作数据库的SQL语句
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="my.service">
<select id="selectStudentByNo" resultType="my.entity.Student">
update student
set sname='caixibei'
where sno=#{sno}
</select>
</mapper>
4、配置spring ioc的上下文配置文件
<!-- 1、加载参数文件db.properties -->
<context:property-placeholder location="classpath:db.properties"/>
<!-- 2、配置数据源：使用c3p0数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="jdbcUrl" value="${jdbc.url}"/>
<property name="driverClass" value="${jdbc.driver}"/>
<property name="user" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
<!--
在Mybatis中我们需要的是一个mybatis-config.xml的文件配置好数据源
，获取SqlSession对象操作数据库
-->
<!-- 3、加载SqlSessionFactoryBean对象 -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<!-- 配置mybatis核心配置文件 -->
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<!-- 加载数据源 -->
<property name="dataSource" ref="dataSource"/>
<!-- 加载映射文件 -->
<property name="mapperLocations" value="classpath:student-mapper.xml"/>
</bean>
<!-- 4、获取SqlSession对象：SqlSessionTemplate是一个安全线程对象，每一次运行都会获取一个新的SqlSession对象 -->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>
<!-- 5、配置SqlSession对象:给StudentService配置属性，必须要有setter()方法 -->
<bean id="studentService" class="my.service.StudentService">
<property name="sqlSession" ref="sqlSession"/>
</bean>
5、配置mybatis核心配置文件
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!--1.全局的setting配置，根据需要添加 -->
<settings>
<!--开启二级缓存 -->
<setting name="cacheEnabled" value="true" />
</settings>
</configuration>
6、前端页面
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Welcome to my WebSite</title>
</head>
<body>
<h3>欢迎来到我的网站，<a href="/ssm/updatePage.action">点击修改信息</a></h3>
</body>
</html>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>更新数据库</title>
</head>
<body>
<form action="/ssm/updateStudent.action" method="post">
请输入您要修改的学号：<input type="text" name="sno" />
<input type="submit" value="确认" />
</form>
${message }
</body>
</html>
7、控制器
package my.controller;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import my.service.StudentService;
@Controller
public class StudentController {
@Autowired
@Qualifier("studentService")
private StudentService studentService;
@RequestMapping(value="/updatePage.action")
public String updatePage() {
return "updateStudent";
}
@RequestMapping(value = "/updateStudent.action")
public String updateStudent(HttpServletRequest request,ModelMap modelMap ) {
String sno = request.getParameter("sno");
studentService.updateStudent(sno);
modelMap.addAttribute("message", "修改成功..");
return "updateStudent";
}
}
8、Dao层接口
package my.dao;
import my.entity.Student;
public interface StudentDao {
//查询学生
public Student selectStudentBySno(String sno) ;
//删除学生
public void deleteStudentBySno(String sno);
//更新学生
public void updateStudent(String sno);
//增加学生
public void insertStudent(Student student);
}
9、业务层
package my.service;
import org.apache.ibatis.session.SqlSession;
import my.dao.StudentDao;
import my.entity.Student;
public class StudentService implements StudentDao{
private SqlSession sqlSession;
public void setSqlSession(SqlSession sqlSession) {
this.sqlSession = sqlSession;
}
@Override
public Student selectStudentBySno(String sno) {
return null;
}
@Override
public void deleteStudentBySno(String sno) {
}
//根据学号修改学生的姓名
@Override
public void updateStudent(String sno) {
int i = sqlSession.update("my.service.selectStudentByNo", sno);
}
@Override
public void insertStudent(Student student) {
}
}
4)测试
5）bingo…完结
