目录

一.将框架打成jar包，然后导入新工程，并且把框架的依赖jar包导入进去

①.我们重新创建一个叫J_mvc_crud 

②.选择我们的框架右键然后选择Export...接着看图

 ③.并且把框架依赖的jar包导入进去

 二.框架的配置文件添加、以及web.xml的配置-以后开源框架的使用从这一步开始

1.把我们的中央控制器配一下，配置我们的环境

2.把开源框架的使用 

三.将分页标签相关文件、及相关助手类导入

 四.基础的增删改查

1.book实体类这里要跟数据库保持一致

2.BookDao方法

3.baseDao是去除重复代码块

4.我们去测试一次，去哪测试junit

5.抛异常是有讲究的什么时候抛什么时候抓，在最底层是抛，在代码的最顶层是抓，那么现在我们的测试里面要抓，因为没有什么地方要掉BookDaoText了所以要抓.

五.通用的增删改

六.完成BookAction

 七.完成mvc.xml的配置

1.我的改了jwj.xml的配置了，那么在web.xml里面也要对其这个名字。

2.把我们的BookAction配置到jwj.xml里面去,把BookAction的路径名copy过去.

3.我们要跳转的界面有三个.

4.转发和重定向的区别:

八.界面运行展示

1.查询和修改是没有问题了

 2.新增和修改

3.界面运行展示

5.乱码问题

 怎么解决：之前我们过滤了book的，现在就要过滤以action结尾的，然后必须要重新启动一下，就不会出现乱码问题了。

九.总结

1.搭建环境 

2. 我们原来的这个dao的编写通过我们这个BaseDao的简化，能够减少我们的代码量了

3.我们的web层相对以前的变化

4.相对于以前我们的servlet需要在web.xml中去配置或者说在上面去添加servlet注解，现在的话不需要了，但是呢我们添加了这个配置文件里面的子控制的一个配置

5..那么我们的分页由原来的这个大量jsp代码变成了我们自定义标签去实现了，就是在我们的界面端也做了优化，对应的是我们之前的jsp标签，自定义jsp标签的内容，

一.将框架打成jar包，然后导入新工程，并且把框架的依赖jar包导入进去

①.我们重新创建一个叫J_mvc_crud 

②.选择我们的框架右键然后选择Export...接着看图

---

我们在去F盘里面去看看有没有有

 ③.并且把框架依赖的jar包导入进去

 二.框架的配置文件添加、以及web.xml的配置-以后开源框架的使用从这一步开始

1.把我们的中央控制器配一下，配置我们的环境

赋值昨天的web.xml代码块：

  J_mvc_crud
  
  	mvc
  	com.jiangwenjuan.framework.DispatcherServlet
  	
  		configLocation
  		/jwj.xml
  	
  
  
  
  	mvc
  	*.action
  

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{
	
//	查询
	public List 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 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;



public class BaseDao {
	
	
	public List executeQuery(String sql,PageBean pageBean,CallBack 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;
		
		
		
		//创建连接
		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);
	}

	
	private String pagePageSQL(String sql, PageBean pageBean) {
		//这里相当于limit 1,10 
	return sql+" limit "+pageBean.getStartIndex()+","+pageBean.getRows();
	}

	
	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 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{
	
//	查询
	public List 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 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{

	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 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 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配置

八.界面运行展示

1.查询和修改是没有问题了

---

---

 2.新增和修改

我们去写一个新增和修改的共同的页码bookEdit.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>







	

		bid:
		bname:
		price:
		
	

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;


@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给组合起来的综合性的案例。

最终我们所有的类:

​​​​​​​