本文档详细介绍了如何使用自定义MVC框架进行项目搭建，包括创建新工程，导入框架及依赖，配置web.xml和框架配置文件，实现分页标签，基础的增删改查操作，以及异常处理。此外，还讲解了通用增删改方法的优化，BookAction的完成，mvc.xml配置，界面运行展示，以及解决乱码问题。最后总结了框架使用的关键步骤和优势。
目录
一.将框架打成jar包，然后导入新工程，并且把框架的依赖jar包导入进去
二.框架的配置文件添加、以及web.xml的配置-以后开源框架的使用从这一步开始
5.抛异常是有讲究的什么时候抛什么时候抓，在最底层是抛，在代码的最顶层是抓，那么现在我们的测试里面要抓，因为没有什么地方要掉BookDaoText了所以要抓.
1.我的改了jwj.xml的配置了，那么在web.xml里面也要对其这个名字。
2.把我们的BookAction配置到jwj.xml里面去,把BookAction的路径名copy过去.
怎么解决：之前我们过滤了book的，现在就要过滤以action结尾的，然后必须要重新启动一下，就不会出现乱码问题了。
2. 我们原来的这个dao的编写通过我们这个BaseDao的简化，能够减少我们的代码量了
4.相对于以前我们的servlet需要在web.xml中去配置或者说在上面去添加servlet注解，现在的话不需要了，但是呢我们添加了这个配置文件里面的子控制的一个配置
5..那么我们的分页由原来的这个大量jsp代码变成了我们自定义标签去实现了，就是在我们的界面端也做了优化，对应的是我们之前的jsp标签，自定义jsp标签的内容，
一.将框架打成jar包，然后导入新工程，并且把框架的依赖jar包导入进去
①.我们重新创建一个叫J_mvc_crud
②.选择我们的框架右键然后选择Export...接着看图
我们在去F盘里面去看看有没有有
③.并且把框架依赖的jar包导入进去
二.框架的配置文件添加、以及web.xml的配置-以后开源框架的使用从这一步开始
1.把我们的中央控制器配一下，配置我们的环境
赋值昨天的web.xml代码块：
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
<display-name>J_mvc_crud</display-name>
<servlet>
<servlet-name>mvc</servlet-name>
<servlet-class>com.jiangwenjuan.framework.DispatcherServlet</servlet-class>
<init-param>
<param-name>configLocation</param-name>
<param-value>/jwj.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>mvc</servlet-name>
<url-pattern>*.action</url-pattern>
</servlet-mapping>
</web-app>2.把开源框架的使用
三.将分页标签相关文件、及相关助手类导入
我们在前面的时候是不是还优化了，除了框架层的优化，优化了参数封装，优化了结果类的跳转，还优化了分页，哪个分页我们没有打jar包.所以我们要借助这些通用分页的代码，通用分页会设计到那些东西类，tld文件要，tld的助手类也要，我们把这两个核心拿过来。
tldcopy到WEB-INF下面去.还要助手类.
最终完成的类就是这样的
四.基础的增删改查
1.book实体类这里要跟数据库保持一致
在mysql操作的数据库表是mybatis_ssm里面的用的表是t_mvc_book
package com.jiangwenjuan.entity;
public class Book {
private int bid;
private String bname;
private float price;
public int getBid() {
return bid;
}
public void setBid(int bid) {
this.bid = bid;
}
public String getBname() {
return bname;
}
public void setBname(String bname) {
this.bname = bname;
}
public float getPrice() {
return price;
}
public void setPrice(float price) {
this.price = price;
}
public Book() {
// TODO Auto-generated constructor stub
}
public Book(int bid, String bname, float price) {
super();
this.bid = bid;
this.bname = bname;
this.price = price;
}
@Override
public String toString() {
return "Book [bid=" + bid + ", bname=" + bname + ", price=" + price + "]";
}
}
2.BookDao方法
package com.jiangwenjuan.dao;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import com.jiangwenjuan.entity.Book;
import com.jiangwenjuan.util.BaseDao;
import com.jiangwenjuan.util.DBAccess;
import com.jiangwenjuan.util.PageBean;
import com.jiangwenjuan.util.StringUtils;
public class BookDao extends BaseDao<Book>{
// 查询
public List<Book> list(Book book,PageBean pageBean) throws Exception{
String sql="select * from t_mvc_book where 1=1";
String bname = book.getBname();
if(StringUtils.isNotBlank(bname)) {
sql+=" and bname like '%"+bname+"%'";
}
// 我后面修改的时候是不是要根据bid去查询所以我们要bid
int bid = book.getBid();
// 前台jsp传递到后台，只要传了就有值，没传就是默认值，默认值就是0
if(bid != 0) {
sql+=" and bid = "+bid;
}
return super.executeQuery(sql, pageBean, rs -> {
List<Book> list = new ArrayList<>();
try {
while(rs.next()) {
list.add(new Book(rs.getInt("bid"), rs.getString("bname"), rs.getFloat("price")));
}
} catch (Exception e) {
e.printStackTrace();
}
return list;
});
}
// 增
public int add(Book book) throws Exception {
Connection con = DBAccess.getConnection();
String sql = "insert into t_mvc_book values(?,?,?)";
PreparedStatement pst = con.prepareStatement(sql);
pst.setObject(1, book.getBid());
pst.setObject(2, book.getBname());
pst.setObject(3, book.getPrice());
return pst.executeUpdate();
}
// 删
public int del(Book book) throws Exception {
Connection con = DBAccess.getConnection();
String sql = "delete from t_mvc_book where bid=?";
PreparedStatement pst = con.prepareStatement(sql);
pst.setObject(1, book.getBid());
return pst.executeUpdate();
}
// 改
public int edit(Book book) throws Exception {
Connection con = DBAccess.getConnection();
String sql = "update t_mvc_book set bname=?,price=? where bid=?";
PreparedStatement pst = con.prepareStatement(sql);
pst.setObject(1, book.getBname());
pst.setObject(2, book.getPrice());
pst.setObject(3, book.getBid());
return pst.executeUpdate();
}
}
3.baseDao是去除重复代码块
package com.jiangwenjuan.util;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
/**
* 将来你不知道你要查询那张表，用泛型来代替
* T代表的是实体类，可以是Book/User/Goods...
* @author 蒋文娟
*
* @date 2022年6月22日 上午12:39:32
*/
public class BaseDao<T> {
public List<T> executeQuery(String sql,PageBean pageBean,CallBack<T> callBack) throws Exception{
// select * from tb_book where bname like '%o%';
//这个查询不行，因为跟上面代码查询组装不起来
// select count(*) from tb_book where bname like '%o%'
//所以说为什么要这么变，因为不仅仅考虑写出来简单，你还要发现转变的问题
// String countsql="select count(1) as n from ("+sql+") t";
//但这个可以组装
//从上面得到select count(1) as n from (select * from tb_book where bname like '%o%') t;
//目的是为了得到总记录数-->得到总页数
// select * from tb_book where bname like '%o%' limit 10,10;
/*
*1.拿到数据库连接
*2.拿到Preparestatement
*3.执行SQL语句
*/
//创建连接
Connection con = null;// 重复代码1
//获取执行对象
PreparedStatement ps = null;// 重复代码2
//获取结果集
ResultSet rs = null;// 重复代码3
//判断是否分页 并且判断是否为true
if(pageBean != null && pageBean.isPagination()) {//说明要分页
//拿到总记录数 拼接原始的mysql
String countSQL = getcountSQL(sql);
con = DBAccess.getConnection();// 重复代码1
ps = con.prepareStatement(countSQL);// 重复代码2
rs= ps.executeQuery();// 重复代码3
//查询出来的总行数是不是单行单列啊，所以说不需要while,判断即可
if(rs.next()) {
//把我们查询出来的总记录数放在pageBean里面，pageBean它是包含了所有的分页的一些元素的实体类
//当前实体类就包含了总记录数
pageBean.setTotal(rs.getString("n"));
}
//拼接
String pageSQL = pagePageSQL(sql,pageBean);
con = DBAccess.getConnection();// 重复代码1
ps = con.prepareStatement(pageSQL);// 重复代码2
rs= ps.executeQuery();// 重复代码3
}
else {
con = DBAccess.getConnection();// 重复代码1
ps = con.prepareStatement(sql);// 重复代码2
rs= ps.executeQuery();// 重复代码3
}
return callBack.foreach(rs);
}
/**
* 拼装第N页的数据的SQL
* @param sql
* @param pageBean
* @return
*/
private String pagePageSQL(String sql, PageBean pageBean) {
//这里相当于limit 1,10
return sql+" limit "+pageBean.getStartIndex()+","+pageBean.getRows();
}
/**
* 拼装符合条件总记录数的SQL
* @param sql
* @return
*/
private String getcountSQL(String sql) {
// select * from tb_book where bname like '%o%';
//这个查询不行，因为跟上面代码查询组装不起来
// select count(*) from tb_book where bname like '%o%'
//所以说为什么要这么变，因为不仅仅考虑写出来简单，你还要发现转变的问题
// String countsql="select count(1) as n from ("+sql+") t";
//下面这行代码就解决了上面的问题，由原始SQL换成查询总行数的SQL
//为什么不是*因为*代表的所以列，而写1代表的是一列，哪个性能更好，肯定是1
return "select count(1) as n from ("+sql+") t";
}
}
4.我们去测试一次，去哪测试junit
其他的就都一样的测试就好了。
package com.jiangwenjuan.dao;
import static org.junit.Assert.*;
import java.util.List;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import com.jiangwenjuan.entity.Book;
import com.jiangwenjuan.util.PageBean;
public class BookDaoTest {
private BookDao db = new BookDao();
@Before
public void setUp() throws Exception {
}
@After
public void tearDown() throws Exception {
}
@Test
public void testList() {
try {
List<Book> list = db.list(new Book(), new PageBean());
for (Book book : list) {
System.out.println(book);
}
} catch (Exception e) {
e.printStackTrace();
}
}
@Test
public void testAdd() {
Book book = new Book(1234321, "1234321", 1234321);
try {
db.add(book);
} catch (Exception e) {
e.printStackTrace();
}
}
@Test
public void testDel() {
Book book = new Book(1234321, "1234321", 1234321);
try {
db.del(book);
} catch (Exception e) {
e.printStackTrace();
}
}
@Test
public void testEdit() {
Book book = new Book(1234321, "12343212222", 1234321);
try {
db.edit(book);
} catch (Exception e) {
e.printStackTrace();
}
}
}
5.抛异常是有讲究的什么时候抛什么时候抓，在最底层是抛，在代码的最顶层是抓，那么现在我们的测试里面要抓，因为没有什么地方要掉BookDaoText了所以要抓.
五.通用的增删改
1.因为上面的bookDao方法大部分都一样除了sql语句不一样以为，然后我们把bookdao里面随便一个方法copy到BaseDao里面进行优化。
//通用的方法
public int executeUpdate(String sql,T t,String[] attrs) throws Exception {
Connection con = DBAccess.getConnection();
PreparedStatement pst = con.prepareStatement(sql);
// 将t 的某一个属性对应的值加到 pst 对象中
for (int i = 0; i < attrs.length; i++) {
Field f = t.getClass().getDeclaredField(attrs[i]);
// 打开访问权限
f.setAccessible(true);
f.get(t);
pst.setObject(i+1, f.get(t));
}
// pst.setObject(2, book.getBname());
// pst.setObject(3, book.getPrice());
return pst.executeUpdate();
}
2.优化好的bookdoa方法,现在的增删改都是两行代码
package com.jiangwenjuan.dao;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import com.jiangwenjuan.entity.Book;
import com.jiangwenjuan.util.BaseDao;
import com.jiangwenjuan.util.DBAccess;
import com.jiangwenjuan.util.PageBean;
import com.jiangwenjuan.util.StringUtils;
public class BookDao extends BaseDao<Book>{
// 查询
public List<Book> list(Book book,PageBean pageBean) throws Exception{
String sql="select * from t_mvc_book where 1=1";
String bname = book.getBname();
if(StringUtils.isNotBlank(bname)) {
sql+=" and bname like '%"+bname+"%'";
}
// 我后面修改的时候是不是要根据bid去查询所以我们要bid
int bid = book.getBid();
// 前台jsp传递到后台，只要传了就有值，没传就是默认值，默认值就是0
if(bid != 0) {
sql+=" and bid = "+bid;
}
return super.executeQuery(sql, pageBean, rs -> {
List<Book> list = new ArrayList<>();
try {
while(rs.next()) {
list.add(new Book(rs.getInt("bid"), rs.getString("bname"), rs.getFloat("price")));
}
} catch (Exception e) {
e.printStackTrace();
}
return list;
});
}
// 增
// public int add(Book book) throws Exception {
// Connection con = DBAccess.getConnection();
// String sql = "insert into t_mvc_book values(?,?,?)";
// PreparedStatement pst = con.prepareStatement(sql);
// pst.setObject(1, book.getBid());
// pst.setObject(2, book.getBname());
// pst.setObject(3, book.getPrice());
// return pst.executeUpdate();
// }
public int add(Book book) throws Exception {
String sql = "insert into t_mvc_book values(?,?,?)";
return super.executeUpdate(sql, book, new String[] {"bid","bname","price"});
}
// 删
// public int del(Book book) throws Exception {
// Connection con = DBAccess.getConnection();
// String sql = "delete from t_mvc_book where bid=?";
// PreparedStatement pst = con.prepareStatement(sql);
// pst.setObject(1, book.getBid());
// return pst.executeUpdate();
// }
public int del(Book book) throws Exception {
String sql = "delete from t_mvc_book where bid=?";
return super.executeUpdate(sql, book, new String[] {"bid"});
}
// 改
// public int edit(Book book) throws Exception {
// Connection con = DBAccess.getConnection();
// String sql = "update t_mvc_book set bname=?,price=? where bid=?";
// PreparedStatement pst = con.prepareStatement(sql);
// pst.setObject(1, book.getBname());
// pst.setObject(2, book.getPrice());
// pst.setObject(3, book.getBid());
// return pst.executeUpdate();
// }
public int edit(Book book) throws Exception {
String sql = "update t_mvc_book set bname=?,price=? where bid=?";
return super.executeUpdate(sql, book, new String[] {"bname","price","bid"});
}
}
3.在上面的测试方法里面去测试一下，看看效果是否根之前一样.
4.增删改都没有问题都可以实现说明可以。其实查询也可以优化查询有三个版本。最终查询的代码量是这么多，只是没有回调.
六.完成BookAction
package com.jiangwenjuan.web;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.jiangwenjuan.dao.BookDao;
import com.jiangwenjuan.entity.Book;
import com.jiangwenjuan.framework.ActionSupport;
import com.jiangwenjuan.framework.ModelDriven;
import com.jiangwenjuan.util.PageBean;
public class BookAction extends ActionSupport implements ModelDriven<Book>{
private Book book = new Book();
private BookDao bookDao = new BookDao();
@Override
public Book getModel() {
return book;
}
// 增 这个execute方法是在ActionSupport里面来的,我们改个名字
public String add(HttpServletRequest req, HttpServletResponse resp) {
try {
bookDao.add(book);
} catch (Exception e) {
e.printStackTrace();
}
// 代表跳到查询界面
return "toList";
}
// 删
public String del(HttpServletRequest req, HttpServletResponse resp) {
try {
bookDao.del(book);
} catch (Exception e) {
e.printStackTrace();
}
// 代表跳到查询界面
return "toList";
}
// 改
public String edit(HttpServletRequest req, HttpServletResponse resp) {
try {
bookDao.edit(book);
} catch (Exception e) {
e.printStackTrace();
}
// 代表跳到查询界面
return "toList";
}
// 查
public String list(HttpServletRequest req, HttpServletResponse resp) {
try {
PageBean pageBean = new PageBean();
// 通用初始化一下
pageBean.setRequest(req);
List<Book> list = bookDao.list(book, pageBean);
req.setAttribute("list", list);
req.setAttribute("pageBean", pageBean);
} catch (Exception e) {
e.printStackTrace();
}
// 执行查询展示
return "list";
}
// 跳转到新增/修改界面
public String preEdit(HttpServletRequest req, HttpServletResponse resp) {
try {
// 拿bid
int bid = book.getBid();
// 当我们点新增的时候是不是没有传bid，只有我们点修改的时候是不是就会传值过来
if(bid!=0) {
// 传递bid到后台，有且只能查出一条数据，那也就意味着list集合中只有一条
List<Book> list = bookDao.list(book, null);
// 查询出来只有一条所以我们就返回到前台去
req.setAttribute("b", list.get(0));
}
} catch (Exception e) {
e.printStackTrace();
}
// 代表跳到编辑界面
return "toEdit";
}
}
七.完成mvc.xml的配置
1.我的改了jwj.xml的配置了，那么在web.xml里面也要对其这个名字。
2.把我们的BookAction配置到jwj.xml里面去,把BookAction的路径名copy过去.
3.我们要跳转的界面有三个.
4.转发和重定向的区别:
案例重定向：假如小坤很缺钱，问小芳借，然后男朋友管的严，然后有问小小借，如果没有，就接着问其他人借，直到能借到钱.
那么这个案例嘞，就是说发送两次借钱的请求，所以说这个就是重定向
案例转发：假如我问悠悠借钱，悠悠说没有，后面还说了一句我不管怎样最终都会把钱借给我，哪怕是没钱，然后悠悠就会去找别人的借，它不管找谁借最终都会借给我，我不管它找谁借了，那都是它的事，我只知道我就借了悠悠的钱。
通过这样：转发它的地址是不会发生改变，那么重定向地址就会发生改变
jwj.xml配置
<?xml version="1.0" encoding="UTF-8"?>
<!-- 哪个类里面包含了整个配置文件中的所有信息 -->
<config>
<action path="/book" type="com.jiangwenjuan.web.BookAction">
<!-- 因为我们要带参数，所以要转发，我们的查询结果要带过去所以为false -->
<forward name="list" path="/bookList.jsp" redirect="false" />
<forward name="toEdit" path="/bookEdit.jsp" redirect="false" />
<!-- 这里的增删改一定要重定向要不然就会出现问题 -->
<forward name="toList" path="/book.action?methodName=list" redirect="true" />
</action>
</config>八.界面运行展示
1.查询和修改是没有问题了
2.新增和修改
我们去写一个新增和修改的共同的页码bookEdit.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<form action="${pageContext.request.contextPath }/book.action?methodName=${empty b ? 'add' : 'edit'}" method="post">
bid:<input type="text" name="bid" value="${b.bid }">
bname:<input type="text" name="bname" value="${b.bname }">
price:<input type="text" name="price" value="${b.price }">
<input type="submit">
</form>
</body>
</html>3.界面运行展示
5.乱码问题
怎么解决：之前我们过滤了book的，现在就要过滤以action结尾的，然后必须要重新启动一下，就不会出现乱码问题了。
package com.jiangwenjuan.util;
import java.io.IOException;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* 过滤器:就是把我们的字符编码集转成UTF-8,jsp默认的编码集是ISO-8859-1,这个就是我们编码集的作用
* 中文乱码处理
* @author 蒋文娟
*
* @date 2022年6月21日 下午8:09:18
*/
@WebFilter("*.action")
public class EncodingFiter implements Filter {
private String encoding = "UTF-8";// 默认字符集
public EncodingFiter() {
super();
}
public void destroy() {
}
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
HttpServletRequest req = (HttpServletRequest) request;
HttpServletResponse res = (HttpServletResponse) response;
// 中文处理必须放到 chain.doFilter(request, response)方法前面
res.setContentType("text/html;charset=" + this.encoding);
if (req.getMethod().equalsIgnoreCase("post")) {
req.setCharacterEncoding(this.encoding);
} else {
Map map = req.getParameterMap();// 保存所有参数名=参数值(数组)的Map集合
Set set = map.keySet();// 取出所有参数名
Iterator it = set.iterator();
while (it.hasNext()) {
String name = (String) it.next();
String[] values = (String[]) map.get(name);// 取出参数值[注：参数值为一个数组]
for (int i = 0; i < values.length; i++) {
values[i] = new String(values[i].getBytes("ISO-8859-1"),
this.encoding);
}
}
}
chain.doFilter(request, response);
}
public void init(FilterConfig filterConfig) throws ServletException {
String s = filterConfig.getInitParameter("encoding");// 读取web.xml文件中配置的字符集
if (null != s && !s.trim().equals("")) {
this.encoding = s.trim();
}
}
}
九.总结
利用自定义mvc框架去开发我们的增删改查，包括以后这个开源框架去做增删改查步骤如下：
1.搭建环境
1.搭建这个框架的环境，包括框架的jar包依赖，然后以及我们的文件配置web.xml的配置，以及框架本身的配置文件的添加，比如说：我们的mvc.xml、jwj.xml等等这就是我们的框架的配置文件
2. 我们原来的这个dao的编写通过我们这个BaseDao的简化，能够减少我们的代码量了
2.我们的增删改查是从我们的实体类开始的，接下来我们就要去建实体类，建完实体类之后，我们的这个dao层是经过了我们之前的BaseDao的优化，所以说导致我们的代码量就会去减少，就是我们的增删改由原来的多行代码变成了两行代码，如果说我们的查询按照我们的第二版本它就会进一步减少，就没有拿过回调函数
3.我们的web层相对以前的变化
3.web层编码通过我们的中央控制器以及模型驱动接口，它把我们原来的参数封装，以及我们的底层的反射动态调用方法，我们以前的doget，dopost方法是不用写的，因为我们继承了子控制器然后配置了web.xml里面的中央控制器，所以说，会发现我们的子控制器相当于我们之前的servlet它的代码量也减少了，总之一行代码就OK了，搞定的原因是框架帮你做了这个事情。
4.相对于以前我们的servlet需要在web.xml中去配置或者说在上面去添加servlet注解，现在的话不需要了，但是呢我们添加了这个配置文件里面的子控制的一个配置
5..那么我们的分页由原来的这个大量jsp代码变成了我们自定义标签去实现了，就是在我们的界面端也做了优化，对应的是我们之前的jsp标签，自定义jsp标签的内容，
通过自定义mvc增删改这个文章就把我们的反射、建模、还有我们的通用分页、自定义标签、自定义mvc给组合起来的综合性的案例。
最终我们所有的类:
893
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
