项目结构：
domain域对象：
package cn.itsource.domain;
public class Student {
/**
* 编号
* */
private Long id;
/**
* 用户名
* */
private String username;
/**
* 密码
* */
private String password;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public String toString() {
return "Student [id=" + id + ", username=" + username + ", password=" + password + "]";
}
}
对象关系映射文件（同domain一个包）：
<?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">
<!-- 完成一个对象关系映射文件 ->
作用：一个对象的所有SQL都应该写在这个映射文件中 这个文件一般和我们的domain写在同一个包里面，取名为
-> domain的名称+Mapper.xml -->
<!-- namespace:命名空间（每个Mapper必须有命名空间） -->
<mapper namespace="cn.itsource.domain.StudentMapper">
<!--
select:它里面写查询语句
id：查询语句的唯一标识（名称不能重复）
如何在 java代码中找到sql语句？ 命名空间+id
例子：cn.itsource.domain.ProductMapper.select
parameterType：传入的参数类型。 除了MyBatis支持的类型，其它的类型都通通使用全限定名
resultType:返回的每一条数据的结果类型（结果类型写权限定名称 ） 查询功能使用
-->
<select id="queryOne" parameterType="Long" resultType="Student">
select * from student where id = #{id}
</select>
<select id="queryAll" resultType="Student">
select * from student
</select>
<insert id="save" parameterType="Student">
insert into student (username,password) values(#{username},#{password})
</insert>
<update id="update" parameterType="Student">
update student set id=#{id}, username=#{username},password=#{password} where id=#{id}
</update>
<delete id="delete" parameterType="Long" >
delete from student where id=#{id}
</delete>
</mapper>
dao层创建一个域对象接口类：
package cn.itsource.dao;
import java.util.List;
import cn.itsource.domain.Student;
public interface IStudentDao {
void save(Student obj);
void update(Student obj);
void delete(Long id);
Student queryOne(Long id);
List<Student> queryAll();
}
测试类（dao层接口同一个包）：测试后台CRUD是否正常
package cn.itsource.dao;
import java.util.List;
import org.junit.Test;
import cn.itsource.dao.impl.StudentDaoImpl;
import cn.itsource.domain.Student;
public class StudentDaoTest {
IStudentDao dao = new StudentDaoImpl();
@Test
public void testSave() {
Student stu = new Student();
stu.setUsername("女神");
stu.setPassword("6666");
dao.save(stu);
}
@Test
public void testUpdate() {
Student stu = dao.queryOne(2L);
stu.setId(14L);
stu.setUsername("帅哥");
dao.update(stu);
}
@Test
public void testDelete() {
dao.delete(14L);
}
@Test
public void testQueryOne() {
Student stu = dao.queryOne(2L);
System.out.println(stu);
}
@Test
public void testQueryAll() {
List<Student> stu = dao.queryAll();
for (Student student : stu) {
System.out.println(student);
}
}
}
创建一个域对象接口类的实现类：
package cn.itsource.dao.impl;
import java.util.List;
import org.apache.ibatis.session.SqlSession;
import cn.itsource.dao.IStudentDao;
import cn.itsource.domain.Student;
import cn.itsource.util.MyBatisUtil;
public class StudentDaoImpl implements IStudentDao {
@Override
public void save(Student obj) {
//通过工具类获取SqlSession对象
SqlSession session = MyBatisUtil.INSTANCE.openSession();
try {
session.insert("cn.itsource.domain.StudentMapper.save", obj);
//提交事务
session.commit();
} catch (Exception e) {
session.rollback();
e.printStackTrace();
}finally{
session.close();
}
}
@Override
public void update(Student obj) {
//通过工具类获取SqlSession对象
SqlSession session = MyBatisUtil.INSTANCE.openSession();
try {
session.update("cn.itsource.domain.StudentMapper.update", obj);
//提交事务
session.commit();
} catch (Exception e) {
session.rollback();
e.printStackTrace();
}finally{
session.close();
}
}
@Override
public void delete(Long id) {
//通过工具类获取SqlSession对象
SqlSession session = MyBatisUtil.INSTANCE.openSession();
try {
session.delete("cn.itsource.domain.StudentMapper.delete", id);
//提交事务
session.commit();
} catch (Exception e) {
session.rollback();
e.printStackTrace();
}finally{
session.close();
}
}
@Override
public Student queryOne(Long id) {
//通过工具类获取SqlSession对象
SqlSession session = MyBatisUtil.INSTANCE.openSession();
try {
//通过session执行sql语句，并返回结果
return session.selectOne("cn.itsource.domain.StudentMapper.queryOne", id);
} catch (Exception e) {
e.printStackTrace();
}finally{
session.close();
}
return null;
}
@Override
public List<Student> queryAll() {
//通过工具类获取SqlSession对象
SqlSession session = MyBatisUtil.INSTANCE.openSession();
try {
return session.selectList("cn.itsource.domain.StudentMapper.queryAll");
} catch (Exception e) {
e.printStackTrace();
}finally{
session.close();
}
return null;
}
}
MyBatis框架工具类：
package cn.itsource.util;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
public enum MyBatisUtil {
/**
* MyBatis三大核心对象特点：
* SqlSessionFactoryBuilder——创建了SqlSessionFactory后，这个类就不需要存在了
* SqlSessionFactory——被创建，SqlSessionFactory应该在你的应用执行期间都存在
* SqlSession——每个线程都应该有它自己的SqlSession实例。SqlSession的实例不能被共享，也是线程不安全的
* */
INSTANCE;
//SqlSessionFactory只需要一个
private static SqlSessionFactory factory;
/**
* 把factory放在静态代码块中的原因？
* 因为factory只需要创建一个，而静态代码块中的代码只会执行一次
* */
static{
try {
//创建一个SqlSession工厂对象，读取我们的核心配置文件
factory = new SqlSessionFactoryBuilder().build(Resources
.getResourceAsStream("mybatis-config.xml"));
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 直接返回一个SqlSession对象
* */
public SqlSession openSession(){
//通过SqlSessionFactory创建SqlSession对象
return factory.openSession();
}
}
Servlet类（用于前端用户完成CRUD）：
package cn.itsource.web.servlet;
import java.io.IOException;
import java.util.List;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import cn.itsource.dao.IStudentDao;
import cn.itsource.dao.impl.StudentDaoImpl;
import cn.itsource.domain.Student;
/**
* 完成前端的CRUD
* */
@WebServlet("/student")
public class StudentServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
IStudentDao dao = new StudentDaoImpl();
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
req.setCharacterEncoding("UTF-8");
/**
* 我怎么知道哪一个请求过来是执行哪一个方法？
* 每次请求让它传一个参数(cmd)过来
* cmd=delete -> 执行删除方法
* cmd=input -> 执行跳转方法
* cmd=edit -> 执行编辑方法
* cmd=list 或者 没有cmd -> 执行查询
**/
String cmd = req.getParameter("cmd");
if("delete".equals(cmd)){
this.delete(req, resp);
}else if("input".equals(cmd)){
this.input(req, resp);
}else if("edit".equals(cmd)){
this.edit(req, resp);
}else{
this.list(req, resp);
}
}
/**
* 显示所有数据
* */
protected void list(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
//1.接收参数（查询所有数据，不需要接收参数）
//2.到dao层拿到用户数据
List<Student> stus = dao.queryAll();
//3.将拿到的数据放到作用域中
req.setAttribute("stus", stus);
//4.跳转：使用请求转发 因为要传参，文件在WEB-INF中
req.getRequestDispatcher("/WEB-INF/student/list.jsp").forward(req, resp);
}
/**
* 添加和修改
* */
protected void edit(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
/**
* 这个方法 是做添加与修改
* 接收id
* 如果id不等于空，并且不等于空字符串，代表id存在
* id存在：就是修改
* id不存在：就是添加
*/
//接收参数用来封装对象
String id = req.getParameter("id");
String username = req.getParameter("username");
String password = req.getParameter("password");
//创建一个Student对象，把获取到的username和password封装到该对象中
Student stu = new Student();
stu.setUsername(username);
stu.setPassword(password);
//判断 如果id不等于空，并且不等于空字符串，代表id存在
if(id!=null && !"".equals(id.trim())){
stu.setId(Long.valueOf(id));
//执行修改
dao.update(stu);
}else {
dao.save(stu);
}
//跳转
resp.sendRedirect("/student");
}
/**
* 删除
* */
protected void delete(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
//接收参数（删除不需要接收参数）
//要删除数据，需要获得前端穿过来的id，因为删除是根据id删除
String id = req.getParameter("id");
//调用删除方法 删除的时候需要传入一个Long型的而获得的id是一个String类型，转换类型
dao.delete(Long.valueOf(id));
//跳转 数据删除后跳转到StudentServlet中的list方法
resp.sendRedirect("/student");
}
/**
* 跳转(中转的servlet) 这个方法用于在edit方法是跳转到哪一个前端页面
* */
protected void input(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
/**
* 又要做添加，又要做修改。
* 如果id不等于空，并且不等于空字符串，代表id存在
* id存在：代表修改
* id不存在：代表添加
*/
String id = req.getParameter("id");
if(id!=null && !"".equals(id.trim())){
Student stu = dao.queryOne(Long.parseLong(id));
//把edit方法中添加和修改后的数据设置到作用域中
req.setAttribute("stu", stu);
}
//跳转：请求转发 ->1.在WEB-INF中
req.getRequestDispatcher("/WEB-INF/student/edit.jsp").forward(req, resp);
}
}
resources资源文件夹：db.properties（连接数据库的） log4j.properties（配置mybatis日志） mybatis-cofig.xml（mybatis核心配置）
db.driver=com.mysql.jdbc.Driver
db.url=jdbc:mysql://localhost:3306/test666
db.username=root
db.password=admin
log4j.rootLogger=ERROR, stdout
#log4j.rootLogger=NONE
log4j.logger.cn.itsource=TRACE
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n
<?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">
<!--
完成一个mybatis-config.xml的文件
-> 作用：配置连接数据库的所有需要的环境
必须连接到所有要使用的映射文件（ProductMapper.xml）
-->
<!--configuration 根目录 -->
<configuration>
<!-- 引入（关联）db.properties文件 -->
<properties resource="db.properties"></properties>
<!-- 配置别名：在MyBatis中为一个类取别名 配置别名是为了在对象映射文件中接收参数类型和返回参数类型时使用-->
<typeAliases>
<!--
设置这个包下面的所有类的别名
<package name="cn.itsource.domain"/>
-->
<!--
设置单个类的别名 alias:取的别名 type：这个别名所对应的Java类 别名使用的时候与大小写无关
-->
<typeAlias alias="Student" type="cn.itsource.domain.Student"/>
</typeAliases>
<!-- 环境们：很多环境 default：表示默认使用哪一个环境-->
<environments default="development">
<!-- 单个环境：一个环境 id：表示这个环境的名称-->
<environment id="development">
<!-- transactionManager：事务管理器 （使用的JDBC事务管理器）-->
<transactionManager type="JDBC"></transactionManager>
<!-- MyBatis自帶POOLED连接池（数据源） -->
<dataSource type="POOLED">
<property name="driver" value="${db.driver}" />
<property name="url" value="${db.url}" />
<property name="username" value="${db.username}" />
<property name="password" value="${db.password}" />
</dataSource>
</environment>
</environments>
<!-- resource:表示 核心配置文件（mybatis-config.xml）必须与所有的对象映射文件（ProductMapper.xml）关联！！！！ -->
<mappers>
<mapper resource="cn/itsource/domain/StudentMapper.xml" />
</mappers>
</configuration>
list.jsp:用于浏览器显示数据库中的student表格
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
<style type="text/css">
table{
border-collapse: collapse;
width:500px;
text-align:center;
}
table th,table td{
border: 1px solid black;
}
</style>
</head>
<body>
<a href="/student?cmd=input">添加</a>
<table>
<tr>
<th>用户名</th>
<th>密码</th>
<th>操作</th>
</tr>
<c:forEach items="${stus}" var="stu">
<tr>
<td>${stu.username}</td>
<td>${stu.password}</td>
<td><a href="/student?cmd=delete&id=${stu.id}">删除</a>|
<a href="/student?cmd=input&id=${stu.id}">修改</a>
</td>
</tr>
</c:forEach>
</table>
</body>
</html>edit.jsp：用于前端显示用户登录样式
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<form action="/student?cmd=edit" method="post">
<input type="hidden" name="id" value="${stu.id}" />
姓名：<input type="text" name="username" value="${stu.username}" /><br />
密码：<input type="password" name="password" value="${stu.password}"/><br />
<input type="submit" value="确定" />
</form>
</body>
</html>
2270
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
