（八）MVC_JavaEE_学习笔记

一、JSON

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。它基于JavaScript（Standard ECMA-262 3rd Edition - December 1999）的一个子集，它利用了JavaScript的一些模式来表示结构化数据。
它是一种数据格式，而非编程语言.
Json并不从属于JavaScript.
很多编程语言都有针对Json的解析器。 .

jason是js里面的对象。
如果查询list，product等这样的数据就可以使用json数据格式。

1.json的使用

• js声明对象，｛｝内是对象。
  
• 对象里包含对象
  
• 对象里包含数组和集合
  
  时刻谨记｛｝表示的是一个对象，[]表示的是一个数组。

2.Xml数据格式 vs JSON数据格式
xml数据格式：

<?xml version="1.0"encoding="utf-8"?>
<country>
    <name>中国</name>
    <province>
        <name>黑龙江</name>
        <cities>
            <city>哈尔滨</city>
            <city>大庆</city>
        </cities>
    </province>
    <province>
        <name>广东</name>
        <cities>
            <city>广州</city>
            <city>深圳</city>
            <city>珠海</city>
        </cities>
    </province>
    <province>
        <name>台湾</name>
        <cities>
            <city>台北</city>
            <city>高雄</city>
        </cities>
    </province>
    <province>
        <name>新疆</name>
        <cities>
            <city>乌鲁木齐</city>
        </cities>
    </province>
</country>

JSON数据格式：

 var pro ={
            "name":"中国",
             "province":[{"name":"黑龙江",”cities”:["哈尔滨","大庆"]},
		          {"name":"广东","cities":["广州","深圳","珠海"]},
		          {"name":"台湾","cities":["台北","高雄"]},
		          {"name":"新疆","cities":["乌鲁木齐"]}
                                   ]
                   }
alert(pro.province[0].cities.city[1]);

js里面的json对象表示方法。
在数据传输过程中，我们一般使用的是json字符串。
Json字符串和json对象的区别就在于属性值加上引号，比如上面的那段代码的name也加上了引号。

两者的比较：

• 可读性
  JSON和XML的可读性可谓不相上下，一边是简易的语法，一边是规范的标签形式，很难分出胜负。
• 可扩展性
  XML天生有很好的扩展性，JSON当然也有，没有什么是XML可以扩展而JSON却不能扩展的。
• 解码难度
  XML的解析方式有两种：一是通过文档模型解析。另外一种方法是遍历节点
  如果预先知道JSON结构的情况下，使用JSON进行数据传递简直是太美妙了，可以写出很实用美观可读性强的代码
• 数据效率
  JSON作为数据包格式传输的时候具有更高的效率，这是因为JSON不像XML那样需要有严格的闭合标签，这就让有效数据量与总数据包比大大提升，从而减少同等数据流量的情况下，网络的传输压力。

3.java语言操纵jason字符串
2.1 json字符串转成java对象
json字符串转成java对象，适用于从对象中取出数据后保存到数据库的场景，比

@Test
    public void method3(){
        String user = "{\"name\":\"lili\",\"password\":\"1234\"}";
        String users = "[{\"name\":\"zhangsan\",\"password\":\"1234\"}, {\"name\":\"zs\",\"password\":\"1234\"}]";
        Gson gson = new Gson();
        //fromJson将json字符串转化成java对象
        User u = gson.fromJson(user, User.class);
        System.out.println(u);
        //对于不止一个user对象的处理
        JsonElement jsonElement = new JsonParser().parse(users);
        JsonArray asJsonArray = jsonElement.getAsJsonArray();
        for (JsonElement element : asJsonArray) {
            User u2 = gson.fromJson(element, User.class);
            System.out.println(u2);
        }
    }

2.2 java对象转成相应字符串
应用场景：查询某个商品，返回商品信息。
如前端传输过来一个商品信息，需要将这些数据保存到数据库。

//手动将java对象转化成json字符串
@Test //单元测试的运行原理：反射
    public void method1(){
        User user = new User();
        user.setUsername("zhangsan");
        user.setPassword("1234");
        //json字符串
        // {"username":"zhangsan","password":"1234"}
        String jsonStr = "{\"username\":\"" + user.getUsername() + "\",\"password\":\"" + user.getPassword() + "\"}";
        System.out.println(jsonStr);
    }
//使用工具类jar包完成对应的转化
@Test
 public void method2(){
     //反射
     User user = new User();
     user.setUsername("zhangsan");
     user.setPassword("1234");
     List<User> users = new ArrayList<>();
     users.add(user);
     //工具类
     Gson gson = new Gson();
     //toJson方法将java对象转化成json字符串
     String json = gson.toJson(user);
     System.out.println(json);
     String s = gson.toJson(users);
     System.out.println(s);
 }

这里面有很多jar包工具类

二、MVC

1.MVC定义：
Model-View-Controller，把一个应用的输入、处理、输出流程按照Model、View、Controller的方式进行分离，这样一个应用被分成三个块，即模型层、视图层、控制层。

数据模型（Model）：封装的是数据模型和所有基于对这些数据的操作。在一个组件中，Model往往表示组件的状态和操作状态的方法。
视图（View）：封装的是对数据Model的一种显示。一个模型可以由多个视图，而一个视图理论上也可以同不同的模型关联起来。
控制器（Control）：封装的是外界作用于模型的操作, 通常，这些操作会转发到模型上，并调用模型中相应的一个或者多个方法。一般Controller在Model和View之间起到了沟通的作用，处理用户在View上的输入，并转发给Model。这样Model和View两者之间可以做到松散耦合，甚至可以彼此不知道对方，而由Controller连接起这两个部分。

2.使用MVC的好处
一方面，分离数据和其表示，使得添加或者删除一个用户数据变得很容易，甚至可以在程序执行时动态的进行。Model和View能够单独的开发，增加了程序可维护性，可扩展性，并使测试变得更为容易。
另一方面，将控制逻辑和表现界面分离，允许程序能够在运行时根据工作流、用户习惯或者模型状态来动态选择不同的用户界面(jsp)。
因此，MVC模式广泛用于Web程序、GUI程序的架构。

3.案例
用户注册和登录
需求：
实现一个注册页面，可以将用户使用表单提交的注册信息保存到一个json文件中。
实现一个登陆页面，当用户输入用户名和密码之后。去之前保存的json文件里看看是否有该用户信息，如果有，就提示登陆成功。没有的话，提示用户名密码错误，重新登陆。
登录成功的用户可以通过注销退出登录。

版本一
LoginServletBak.java

@WebServlet("/loginbak")
public class LoginServletBak extends HttpServlet {
    //迪米特法则：接触的人越少越安全 不要和陌生人说话
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取请求参数
		String username = request.getParameter("username");
        String password = request.getParameter("password");
        String gender = request.getParameter("gender");
        //校验 判断是否为空等
        if(StringUtils.isEmpty(username) || StringUtils.isEmpty(password) || StringUtils.isEmpty(gender)){
            response.getWriter().println("参数不能为空");
            return;
        }
        //暂时先不用数据库  使用json文件存储数据
		//根据请求参数创建一个user对象
        User user = new User(username, password, gender);
        //json文件里面的数据取出来，判断用户名是否存在，存在----返回需要更换用户名  不存在--注册
        //json文件的注册流程：
        //1.将里面的数据转成list user形式
        //2.判断用户名是否存在
        //3.把原先的用户信息和新增的用户信息一并写入到json文件中
		//获取存放user信息的json文件的路径
        String path = LoginServletBak.class.getClassLoader().getResource("user.json").getPath();
		//为user.json文件创建输入流对象
        FileInputStream inputStream = new FileInputStream(new File(path));
		//创建输出流对象
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        int length = 0;
        byte[] bytes = new byte[1024];
		//读取文件内容放入输出流
        while ((length = inputStream.read(bytes)) != -1){
            outputStream.write(bytes, 0, length);
        }
		//利用输出流将文件内容赋值给jsonStr字符串
        String jsonStr = outputStream.toString("utf-8");
		//新建一个user的List
        List<User> users = new ArrayList<>();
        Gson gson = new Gson();
        if(!StringUtils.isEmpty(jsonStr)){
            //之前有人注册过，获取List<User>中的user元素
            JsonElement jsonElement = new JsonParser().parse(jsonStr);
            JsonArray jsonArray = jsonElement.getAsJsonArray();
            for (JsonElement element : jsonArray) {
				//利用Gson将json字符串转换成java的user对象
                User u = gson.fromJson(element, User.class);
				//如果json文件中的用户名和用户输入的用户名相同，提示用户名已经存在
                if(u.getUsername().equals(username)){
                    response.getWriter().println("当前用户名已经存在，请更换用户名");
                    return;
                }
				//将取出的user对象添加到users数组中
                users.add(u);
            }
        }
        //空的情况，表示第一次用 第一个人注册，直接添加到users数组中
        users.add(user);
		//将java的users数组转换成json字符串user_info 
        String user_info = gson.toJson(users);
		//创建输出流对象
        FileOutputStream fileOutputStream = new FileOutputStream(new File(path));
		//将用户信息重新写入user.json文件，编码格式utf-8
        fileOutputStream.write(user_info.getBytes("utf-8"));
		//并且输出提示注册成功
        response.getWriter().println("注册成功，即将跳转至登录页面");
		//刷新跳转到登录页面
        response.setHeader("refresh","2;url=" + request.getContextPath() + "/login.jsp");
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }
}

StringUtils .java

public class StringUtils {
    public static boolean isEmpty(String s) {
        if(s == null || "".equals(s.trim())){
            return true;
        }
        return false;
    }
}

GlobalFilter .java

@WebFilter("/*")
public class GlobalFilter implements Filter {
    public void destroy() {
    }

    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");
        resp.setContentType("text/html;charset=utf-8");
        chain.doFilter(req, resp);
    }

    public void init(FilterConfig config) throws ServletException {

    }
}

login.jsp

<%--
  Created by IntelliJ IDEA.
  User: HP
  Date: 2020/8/3
  Time: 19:11
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <form action="<%=request.getContextPath()%>/loginbak" method="post" >
        <input type="text" name="username"><br>
        <input type="password" name="password"><br>
        <input type="submit">
    </form>

</body>
</html>

register.jsp

<%--
  Created by IntelliJ IDEA.
  User: HP
  Date: 2020/8/3
  Time: 19:11
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<form action="<%=request.getContextPath()%>/loginbak" method="post" >
    <input type="text" name="username"><br> <!--注意type和name之间不能有逗号-->
    <input type="password" name="password"><br>
    <input type="radio" name="gender" value="male">男
    <input type="radio" name="gender" value="female">女<br>
    <input type="submit">
</form>
</body>
</html>

User.java

public class User {
    private String username;

    private String password;

    private String gender;

    public User() {
    }

    public User(String username, String password, String gender) {
        this.username = username;
        this.password = password;
        this.gender = gender;
    }

    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;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", gender='" + gender + '\'' +
                '}';
    }
}

用户注册和登录
改写前面讲解的用户注册和登陆案例，实现如下需求：
1、把json保存用户信息更换成数据库保存
尝试理解MVC模式的优点

接下来需要变更，从一种实现方式变更为另外一种实现方式，上面那套代码需要做的改变如果非常多，那么就是有问题的。

只有红框区域的代码是不需要修改的，其他地方都需要修改。

参照MVC框架，可以看见代码的耦合性非常强。
所以我们使用MVC的思想对代码做进一步的优化。

那么版本一的各部分代码究竟属于mvc里面的哪一个模块？
Model：bean、对于bean的操作，用户注册、登录、查询、新增、修改等
View：视图。Jsp ，response，输出
Controller：控制器。Servlet，逻辑校验，调用model代码，根据结果再调用view代码。

注：将可变的地方封装起来，封装成一个静态方法。将功能部分抽成方法，可以从大的部分开始一点一点逐步抽成小的方法，一步一步细化。

版本二（注意不要忘记修改jsp文件中action参数为当前的servlet）

@WebServlet("/login")
public class LoginServlet extends HttpServlet {
    //迪米特法则：接触的人越少越安全 不要和陌生人说话
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取请求参数
		String username = request.getParameter("username");
        String password = request.getParameter("password");
        String gender = request.getParameter("gender");
        //校验 判断是否为空等
        if(StringUtils.isEmpty(username) || StringUtils.isEmpty(password) || StringUtils.isEmpty(gender)){
            response.getWriter().println("参数不能为空");
            return;
        }
        //暂时先不用数据库  使用json文件存储数据
		//根据请求参数创建一个user对象
        User user = new User(username, password, gender);
        //json文件里面的数据取出来，判断用户名是否存在，存在----返回需要更换用户名  不存在--注册
        //json文件的注册流程：
        //1.将里面的数据转成list user形式
        //2.判断用户名是否存在
        //3.把原先的用户信息和新增的用户信息一并写入到json文件中
        //改成这种形式之后，接下来变更到mysql，需要变化哪些？
        int register = UserJsonModel.register(user);
        //int register = UserMysqlModel.register(user);
        if(register == 404){
            response.getWriter().println("用户名已经存在，请更换用户名");
            return;
        }
        response.getWriter().println("注册成功，即将跳转至登录页面");
        response.setHeader("refresh","2;url=" + request.getContextPath() + "/login.jsp");
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    }
}

UserJsonModel .java

public class UserJsonModel {
    /**
     *
     * @param user
     * @return code 200表示注册成功，404表示用户名已经存在，500注册异常
     * @throws IOException
     */
    public static int register(User user) throws IOException {
        String path = UserJsonModel.class.getClassLoader().getResource("user.json").getPath();
        FileInputStream inputStream = new FileInputStream(new File(path));
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        int length = 0;
        byte[] bytes = new byte[1024];
        while ((length = inputStream.read(bytes)) != -1){
            outputStream.write(bytes, 0, length);
        }
        String jsonStr = outputStream.toString("utf-8");
        List<User> users = new ArrayList<>();
        Gson gson = new Gson();
        if(!StringUtils.isEmpty(jsonStr)){
            //之前有人注册过 List<User>
            JsonElement jsonElement = new JsonParser().parse(jsonStr);
            JsonArray jsonArray = jsonElement.getAsJsonArray();
            for (JsonElement element : jsonArray) {
                User u = gson.fromJson(element, User.class);
                if(u.getUsername().equals(user.getUsername())){
                    return 404;
                }
                users.add(u);
            }
        }
        //空的情况，表示第一次用 第一个人注册
        users.add(user);
        String user_info = gson.toJson(users);
        FileOutputStream fileOutputStream = new FileOutputStream(new File(path));
        fileOutputStream.write(user_info.getBytes("utf-8"));
        return 200;
    }
}

UserMysqlModel .java（暂时不实现）

public class UserMysqlModel {
    public static int register(User user) {
        return 0;
    }
}

还有没有可以进一步优化的空间？
此时代码已经符合了MVC的设计思想，但是此时还存在着一些问题。
当前是在注册模块里，要是接下来在登录、查询、新增这些模块中，如果需求发生变更，这些地方是不是全部都要变一下。如何能够让变化的地方尽可能少呢？
1.方法的名称、参数最好保持相同
2.返回值保持相同
3.凡是UserJsonModel全部更换为UserMysqlModel，变跟的地方也很多

其实是想做一个规范。接口天生就是用来做规范的。
所以需要将json和mysql的实现抽提成一个接口作为规范，然后它们俩分别实现。
此时又给他们取了一个新的名词：UserJsonModel------->UserDao（Data Access Object）。专门处理数据的

由MVC引出三层架构。

三、三层架构

首先导入数据库的包，配置文件，工具类Utils
版本三
1.model文件夹
User.java

2.filter文件夹
GlobalFilter.java

3.utils文件夹
StringUtils.java

DruidUtils.java

public class DruidUtils {

    private static DataSource dataSource;

    static {
        //从ds里面去获取，得到datasource即可
        try {
            Properties properties = new Properties();
            //流 -----> file ----- path
            //假如想将配置文件放在WEB-INF目录下 realPath
            //那么当前配置文件必须要有一个API来接收request或者context，否则无法获取路径
            //但是如果这么做了以后，那么今后该配置文件只能处理EE项目，SE项目需要重新在写一份
            //那么，有没有一种方式，既可以处理EE也可以处理SE呢？
            //有办法。利用类加载器来帮助我们获取流信息
            //输入空字符串的时候，其实是到com同级目录
            InputStream inputStream = DruidUtils.class.getClassLoader().getResourceAsStream("druid.properties");
            properties.load(inputStream);
            dataSource = DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    public static Connection getConnection() throws SQLException {
        return getDataSource().getConnection();
    }


    public static DataSource getDataSource(){
        return dataSource;
    }
}

FileUtils.java

public class FileUtils {
    /**
     * 读取src目录下的文件内容
     * @param filename
     * @return
     */
    public static String readFromFile(String filename) throws IOException {
        String path = FileUtils.class.getClassLoader().getResource(filename).getPath();
        FileInputStream inputStream = new FileInputStream(new File(path));
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        int length = 0;
        byte[] bytes = new byte[1024];
        while ((length = inputStream.read(bytes)) != -1){
            outputStream.write(bytes, 0, length);
        }
        return outputStream.toString("utf-8");
    }

    /**
     *
     * @param filename
     * @param content 写入到filename中的内容
     * @throws IOException
     */
    public static void writeFile(String filename, String content) throws IOException {
        String path = FileUtils.class.getClassLoader().getResource(filename).getPath();
        FileOutputStream fileOutputStream = new FileOutputStream(new File(path));
        fileOutputStream.write(content.getBytes("utf-8"));
    }
}

4.service文件夹
UserService.java

public interface UserService {
    int register(User user);

    Map queryPage(String pagesize, String currentPage);

    boolean login(String username, String password);
}

UserServiceImpl.java

public class UserServiceImpl implements UserService {

    private UserDao userDao = new UserMysqlDao();

    @Override
    public int register(User user) {
        return userDao.register(user);
    }

    @Override
    public Map queryPage(String pagesize, String currentPage) {
        //处理很多事情
        //1.查询总条目
        //Integer number =  userDao.getTotalCount();
        //2.查询当前页的具体是数据
        //List<User> userList = userDao.queryPageUsers(Integer.parseInt(pagesize), Integer.parseInt(currentPage));
        //3.计算得到总页数
       // number / pagesize
        //4.返回map
        HashMap<Object, Object> map = new HashMap<>();
        //map.put()
        return map;
    }

    @Override
    public boolean login(String username, String password) {
        return userDao.login(username, password);
    }
}

5.dao文件夹
UserDao.java

public interface UserDao {

    int register(User user);

    boolean login(String username, String password);
}

UserJsonDao.java

public class UserJsonDao implements UserDao {

    /**
     *
     * @param user
     * @return code 200表示注册成功，404表示用户名已经存在，500注册异常
     * @throws IOException
     */
    public int register(User user) {
        String jsonStr = null;
        try {
            jsonStr = FileUtils.readFromFile("user.json");
        } catch (IOException e) {
            e.printStackTrace();
        }
        List<User> users = new ArrayList<>();
        Gson gson = new Gson();
        if(!StringUtils.isEmpty(jsonStr)){
            //之前有人注册过 List<User>
            JsonElement jsonElement = new JsonParser().parse(jsonStr);
            JsonArray jsonArray = jsonElement.getAsJsonArray();
            for (JsonElement element : jsonArray) {
                User u = gson.fromJson(element, User.class);
                if(u.getUsername().equals(user.getUsername())){
                    return 404;
                }
                users.add(u);
            }
        }
        //空的情况，表示第一次用 第一个人注册
        users.add(user);
        String user_info = gson.toJson(users);
        try {
            FileUtils.writeFile("user.json", user_info);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return 200;
    }

    @Override
    public boolean login(String username, String password) {
        return false;
    }
}

UserMysqlDao.java

public class UserMysqlDao implements UserDao{

    public int register(User user) {
        // username字段设置unique，只需要放心大胆的插入，如果重复代码会进入catch return 404
        QueryRunner runner = new QueryRunner(DruidUtils.getDataSource());
        try {
            runner.update("insert into user (username,password,gender) values (?,?,?)",
                    user.getUsername(),
                    user.getPassword(),
                    user.getGender());
            // sql
        } catch (SQLException e) {
            e.printStackTrace();
            return 404;
        }
        return 200;
    }

    @Override
    public boolean login(String username, String password) {
        QueryRunner runner = new QueryRunner(DruidUtils.getDataSource());
        try {
            User user = runner.query("select * from user where username = ? and password = ?", new BeanHandler<>(User.class),
                    username,
                    password);
            if(user != null){
                return true;
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return false;
    }
}

6.controller文件夹
UserServlet.java

@WebServlet("/user")
public class UserServlet extends HttpServlet {

   // private UserDao userDao =  new UserMysqlDao();//         new UserJsonDao();

    private UserService userService = new UserServiceImpl();


    //迪米特法则：接触的人越少越安全 不要和陌生人说话
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String op = request.getParameter("op");
        if("login".equals(op)){
            login(request, response);
        }else if("register".equals(op)){
            register(request, response);
        }
    }

    private void register(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String username = request.getParameter("username");
        String password = request.getParameter("password");
        String gender = request.getParameter("gender");
        //校验 判断是否为空等
        if(StringUtils.isEmpty(username) || StringUtils.isEmpty(password) || StringUtils.isEmpty(gender)){
            response.getWriter().println("参数不能为空");
            return;
        }
        //暂时先不用数据库  json文件
        User user = new User(username, password, gender);
        //json文件里面的数据取出来，判断用户名是否存在，存在----返回需要更换用户名  不存在--注册
        //json文件的注册流程：
        //1.将里面的数据转成list user形式
        //2.判断用户名是否存在
        //3.把原先的用户信息和新增的用户信息一并写入到json文件中
        //改成这种形式之后，接下来变更到mysql，需要变化哪些？
        int register = userService.register(user);
        if(register == 404){
            response.getWriter().println("用户名已经存在，请更换用户名");
            return;
        }
        response.getWriter().println("注册成功，即将跳转至登录页面");
        response.setHeader("refresh","2;url=" + request.getContextPath() + "/login.jsp");
    }

    private void login(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String username = request.getParameter("username");
        String password = request.getParameter("password");
        //校验   判空
        boolean result =  userService.login(username, password);
        if(result){
            response.getWriter().println("登录成功， 跳转至个人主页");
            request.getSession().setAttribute("username", username);
            return;
        }
        response.getWriter().println("登录失败，确认用户名和密码");
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String op = request.getParameter("op");
        if("queryPage".equals(op)){
            queryPage(request, response);
        }
    }

    private void queryPage(HttpServletRequest request, HttpServletResponse response) {
        String pagesize = request.getParameter("pagesize");
        String currentPage = request.getParameter("currentPage");
        //校验 不通过下面的代码没有资格走
        //判空 是否是数字
        Map result =  userService.queryPage(pagesize,currentPage);
        //放入request域 转发
    }
}

7.jsp文件
login.jsp

<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2020/8/3
  Time: 10:27
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <form action="<%=request.getContextPath()%>/user" method="post">
        <input type="hidden" name="op" value="login">
        <input type="text" name="username"><br>
        <input type="password" name="password"><br>
        <input type="submit">
    </form>
</body>
</html>

register.jsp

<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2020/8/3
  Time: 10:27
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <form action="<%=request.getContextPath()%>/user" method="post">
        <input type="hidden" name="op" value="register">
        <input type="text" name="username"><br>
        <input type="password" name="password"><br>
        <input type="radio" name="gender" value="male">男
        <input type="radio" name="gender" value="female">女<br>
        <input type="submit">
    </form>
</body>
</html>

展示层、业务层，数据层
controller，view、 service、 dao
对于一些业务逻辑复杂的，比如分页查询，一次查询是解决不了问题的，这个时候使用service会很方便。

分页查询返回的结果：
1.一共多少条纪录，查询count
2.一共多少页 计算
3.当前页应该显示的具体条目
limit pagesize offfset(currentPage - 1)*pageSize

注意：
1.尽量一个dao里面只有一个查询
2.模拟查询案例：
在servlet里面如何区分login还是register
< input type=“hidden” >
3.不要在get方法中取出过多的参数
4.校验放在contoller里面，不要放在service里面
5.一个模块写到一个servlet，比如用户模块，管理员模块