用IDEA配置web项目坑点

环境问题

利用IDEA创建一个Web项目

所有JDK要和系统路径的一致，保证没有多个JDK

Tomcat启动失败问题

执行语句的问题

IDEA不能输出中文的问题

Day 2

Mybatis框架

Java框架基础知识

• entity层，实体层，用于存放实体类，与数据库中属性基本保持一致，实现get和set方法
• mapper层，别名dao层，对数据库数据持久化操作，其方法语句直接针对数据库操作，主要实现一些增删改查操作
• service层，业务层，给controller层的类提供接口调用，一般声明自己写的方法，具体实现在servicelmpl中
• control层，别名web层，控制层，负责具体模块的业务流程控制，需要调用service逻辑涉及的接口来控制业务流程。controller层通过接收前端H5或者APP传来的参数进行业务操作，再将处理结果返回到前端。

在entity层开发Mybatis框架

项目结构：

需要将mybatis-3.4.6.jar文件移入./web/WEB-INF/lib下（即导入依赖包）（不是lib目录下，根据之前指定的依赖包路径决定依赖包放置位置）

ShopInfo文件的编写：

1、确定ShopInfo类的成员（即读取的数据条目的表头属性），并且为该类的成员编写get & set方法，自动生成代码的方法：光标放置在某一成员上，右键点击generate，选择getter and sentter。本例子中有三个属性，因此生成三个get，三个set IDEA代码生成Generate_idea generate CSDN博客

最后再生成to string方法，用于将读取的数据以string类型输出，并且实现字符串拼接。

@Override是伪代码,表示重写(当然不写也可以)，不过写上有如下好处: 1、可以当注释用,方便阅读； 2、编译器可以给你验证@Override下面的方法名是否是你父类中所有的，如果没有则报错。例如，你如果没写@Override，而你下面的方法名又写错了，这时你的编译器是可以编译通过的，因为编译器以为这个方法是你的子类中自己增加的方法。

最终代码如下

​x
package edu.ustb.entity;

              
public class ShopInfo {
    private int shopId;
    private String shopName;
    private String color;

              
    public int getShopId() {
        return shopId;
    }

              
    public void setShopId(int shopId) {
        this.shopId = shopId;
    }

              
    public String getShopName() {
        return shopName;
    }

              
    public void setShopName(String shopName) {
        this.shopName = shopName;
    }

              
    public String getColor() {
        return color;
    }

              
    public void setColor(String color) {
        this.color = color;
    }

              
    @Override
    public String toString() {
        return "ShopInfo{" +
                "shopId=" + shopId +
                ", shopName='" + shopName + '\'' +
                ", color='" + color + '\'' +
                '}';
    }
}

ShopInfoMapper.xml文件的编写：

该文件用于编写封装的session方法中如何调用数据库的接口，即select中间的内容，一对select中是一条语句，可以增加，每对select中定义一条mysql语句，以及其调用id，以及返回值类型，本例中返回类型是ShopInfo代表上文中的ShopInfo类

这里的类型需要增加命名空间来指向本项目下的具体类

xxxxxxxxxx
<?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="edu.ustb.entity.ShopInfoMapper">

              
    <select id="selectById" resultType="edu.ustb.entity.ShopInfo">
        select * from shopinfo where shopid= #{id};
    </select>
    <!--此处可以添加数据库命令-->
</mapper>

mybatis-config.xml文件的编写：

是mybatis的配置文件，用于确定所关联的数据库基本信息，需要修改driver驱动器，url接口，username登录用户名，password密码，来连接对应数据库

如果构建的不是空项目而是web项目，则需要将Mybatis-config.xml文件放置在resource默认源目录下

注意附上的注释

xxxxxxxxxx
<?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="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/yaolegoudb?useSSL=false&amp;allowPublicKeyRetrieval=true&amp;serverTimezone=GMT%2B8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
                <!--此处要修改-->
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="edu/ustb/entity/ShopInfoMapper.xml"/>
    </mappers>
</configuration>

测试文件MybatisTest的编写：

该文件用于测试mybatis框架是否搭建成功，

SqlSession是MyBatis的关键对象，它是应用程序与持久层之间交互操作的一个单线程对象,类似于JDBC中的Connection。SqlSession对象完全包含以数据库为背景的所有执行SQL操作的方法，它的底层封装了JDBC连接，可以用SqlSession实例来直接执行被映射的SQL语句。

mybatis框架过程

• 定义一个Configuration对象，其中包含数据源、事务、mapper文件资源以及影响数据库行为属性设置settings
• 通过配置对象，则可以创建一个SqlSessionFactoryBuilder对象
• 通过 SqlSessionFactoryBuilder 获得SqlSessionFactory 的实例。
• SqlSessionFactory 的实例可以获得操作数据的SqlSession实例，通过这个实例对数据库进行操作

本例子的SqlSessionFactoryBuilder是通过XML配置文件构建出的，而不是通过Java代码生成的

xxxxxxxxxx
package edu.ustb.test;

              
import edu.ustb.entity.ShopInfo;
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.Before;
import org.junit.Test;

              
import java.io.IOException;
import java.io.InputStream;

              
public class MybatisTest {
    @Test
    public void TestSelect() throws IOException{
        InputStream inputStream = Resources.getResourceAsStream("edu/ustb/mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

              
        SqlSession session = sqlSessionFactory.openSession();

              
        ShopInfo si = (ShopInfo)session.selectOne("edu.ustb.entity.ShopInfoMapper.selectById",30);

              
//        session.getMapper();

              
        System.out.println(si);
    }

              
}

idea报错，Cannot resolve symbol ‘junit

使用mapper层开发mybatis

mapper层（dao层）实现mybatis开发，它可以不用写实现类，它能以代理方式自动生成实现代码。

但是，使用mapper开发，必须遵循以下原则：

• mapper.xml文件里的namespace属性值和接口必须一致
• 接口中的方法名必须和mapper.xml中的id保持一致
• 接口中的方法名必须和mapper.xml配置中的resultType保持一致
• 参数的类型保持一致（在有parameterType参数的情况下）

项目结构，新增dao层文件夹：

针对dao包下的ShopInfoMapper：

定义了两个方法，具体实现再xml中，需要保证定义的方法满足之前的mapper开发准则

这里需要定义的是一个接口interfa，而不是类class需要注意

xxxxxxxxxx
package edu.ustb.dao;

              
import edu.ustb.entity.ShopInfo;
import java.util.ArrayList;

              
public interface ShopInfoMapper {
    public ShopInfo selectById(int id);
    public ArrayList<ShopInfo> selectAll();
}

针对ShopInfoMapper.xml：

类似entity层的开发，mapper层需要遵循的规则体现在接口的实现上

xxxxxxxxxx
<?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="edu.ustb.dao.ShopInfoMapper">

              
    <select id="selectById" resultType="edu.ustb.entity.ShopInfo">
        select * from shopinfo where shopid= #{id};
    </select>
    <select id="selectAll" resultType="edu.ustb.entity.ShopInfo">
        select * from shopinfo;
    </select>
</mapper>

针对mybatis-config.xml的修改：

这里是关于mybatis的配置文件，因此当有新增的mapper实现的时候，需要在这里新增对应的源文件

注意代码中附上的注释

xxxxxxxxxx
<?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="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/yaolegoudb?useSSL=false&amp;allowPublicKeyRetrieval=true&amp;serverTimezone=GMT%2B8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
                <!--此处要修改-->
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="edu/ustb/entity/ShopInfoMapper.xml"/>
        <!--新增的关于dao的Mapper配置文件-->
        <mapper resource="edu/ustb/dao/ShopInfoMapper.xml"/>
    </mappers>
</configuration>

测试文件MybatisTest的修改：

xxxxxxxxxx
package edu.ustb.test;

              
import edu.ustb.dao.ShopInfoMapper;
import edu.ustb.entity.ShopInfo;
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.Test;

              
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;

              
public class MybatisTest {
    @Test
    public void TestSelect() throws IOException{
        InputStream inputStream = Resources.getResourceAsStream("edu/ustb/mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

              
        SqlSession session = sqlSessionFactory.openSession();
//entity层的实现
//        ShopInfo si = (ShopInfo)session.selectOne("edu.ustb.entity.ShopInfoMapper.selectById",30);
        ShopInfoMapper siMapper = session.getMapper(ShopInfoMapper.class);
//dao层的实现
        ShopInfo si = siMapper.selectById(30);
        System.out.println(si);
    }

              
    @Test
    public void TestSelectAll() throws IOException{
        InputStream inputStream = Resources.getResourceAsStream("edu/ustb/mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

              
        SqlSession session = sqlSessionFactory.openSession();
//entity层的实现
//        ShopInfo si = (ShopInfo)session.selectOne("edu.ustb.entity.ShopInfoMapper.selectById",30);
        ShopInfoMapper siMapper = session.getMapper(ShopInfoMapper.class);
//dao层的实现
        ArrayList<ShopInfo> list = siMapper.selectAll();
        System.out.println(list);
    }
}

比起entity层的调用更方便

Day 3

使用注解的mybatis实现：

mybatis的注解和xml方式不能同时对于同一个方法使用，因此该部分需要删除对应方法的xml文件再编写注释。

ShopInfoMapper的修改:

只需要再注释内新增sql语句

xxxxxxxxxx
package edu.ustb.dao;
import edu.ustb.entity.ShopInfo;
import java.util.ArrayList;
import org.apache.ibatis.annotations.Select;

              
public interface ShopInfoMapper {

              
    @Select("select * from shopinfo where shopid= #{id}")
    public ShopInfo selectById(int id);

              
    @Select("select * from shopinfo")
    public ArrayList<ShopInfo> selectAll();
    
}

mybatis-config全局配置文件的修改：

需要新增带有注解方法的路径

xxxxxxxxxx
<?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="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/yaolegoudb?useSSL=false&amp;allowPublicKeyRetrieval=true&amp;serverTimezone=GMT%2B8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
                <!--此处要修改-->
            </dataSource>
        </environment>
    </environments>
    <mappers>
<!--        <mapper resource="edu/ustb/entity/ShopInfoMapper.xml"/>-->
        <!--新增的关于dao的Mapper配置文件-->
<!--        <mapper resource="edu/ustb/dao/ShopInfoMapper.xml"/>-->
        <!--新增的带有注释的包存在路径-->
        <package name="edu/ustb/dao"/>
    </mappers>
</configuration>

对于测试文件的便捷实现：

新增before和after方法，在每个方法前自动实现sessionFactory的创建与session的实例化，以及在方法结束后对于session的回收关闭

xxxxxxxxxx
package edu.ustb.test;

              
import edu.ustb.dao.ShopInfoMapper;
import edu.ustb.entity.ShopInfo;
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.After;
import org.junit.Before;
import org.junit.Test;

              
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;

              
public class MybatisTest {
    private SqlSession session = null;

              
    @Before
    public void Before() throws IOException{
        InputStream inputStream = Resources.getResourceAsStream("edu/ustb/mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        session = sqlSessionFactory.openSession();
    }

              
    @Test
    public void TestSelect() throws IOException{
//entity层的实现
//        ShopInfo si = (ShopInfo)session.selectOne("edu.ustb.entity.ShopInfoMapper.selectById",30);
        ShopInfoMapper siMapper = session.getMapper(ShopInfoMapper.class);
//dao层的实现
        ShopInfo si = siMapper.selectById(30);
        System.out.println(si);
    }

              
    @Test
    public void TestSelectAll() throws IOException{
//entity层的实现
//        ShopInfo si = (ShopInfo)session.selectOne("edu.ustb.entity.ShopInfoMapper.selectById",30);
        ShopInfoMapper siMapper = session.getMapper(ShopInfoMapper.class);
//dao层的实现
        ArrayList<ShopInfo> list = siMapper.selectAll();
        System.out.println(list);
    }

              
    @After
    public void After() throws IOException{
        session.close();
    }
}

before&after是java默认方法，自动执行

数据项插入、更新、删除的实现：

1、在ShopInfoMapper中新增对应的注解

xxxxxxxxxx
@Insert("INSERT INTO `shopinfo` (`ShopName`,`ShopMiaoShu`,`ShopPrice`,`ChiCun`,`Color`,`ZhuRenUser`,`ShopTypeId`,`Image`,`Context`,`XiaoLiangCount`) "+
            "VALUES (#{shopName},'',100,'',#{color},'',2,'','',0)")
    public int insert(ShopInfo shopInfo);

              
@Update("UPDATE `shopinfo` SET `ShopName` = #{shopName}, `Color` = #{color} WHERE `ShopId` = #{shopId}")
    public int update(ShopInfo shopInfo);

              
@Delete("delete from shopinfo WHERE `ShopId` = #{id}")
    public int delete(int id);

2、在测试中实现相应测试方法

xxxxxxxxxx
@Test
    public void testInsert() throws IOException {
        ShopInfoMapper siMapper = session.getMapper(ShopInfoMapper.class);
        ShopInfo shopInfo = new ShopInfo();
        shopInfo.setShopId(128);
        shopInfo.setShopName("测试商品");
        shopInfo.setColor("pink, purple, blue");
        int result = siMapper.insert(shopInfo);
        if (result > 0) {
            System.out.println("添加成功! ! ! !");
            session.commit();
        }
        else{
            System.out.println("失败");
        }
    }

              
    @Test
    public void testUpdate() throws IOException{
        ShopInfoMapper siMapper = session.getMapper(ShopInfoMapper.class);
        ShopInfo shopInfo = new ShopInfo();
        shopInfo.setShopId(128);
        shopInfo.setShopName("测试商品111111111111");
        shopInfo.setColor("pink,purple,blue,yellow");
        int result = siMapper.update(shopInfo);
        if(result > 0)
        {
            System.out.println("修改成功!\n");
            session.commit();
        }
        else{
            System.out.println("失败\n");
        }
    }

              
    @Test
    public void testDelete() throws IOException {
        ShopInfoMapper siMapper = session.getMapper(ShopInfoMapper.class);
        int result = siMapper.delete( 128);
        if(result > 0) {
            System.out.println("删除成功! ! !!");
            session.commit();
        }
        else {
            System.out.println("失败");
        }
    }

事务需要提交以及回滚，类比github库的推送与回滚，在mybatis中提交 session.commit();

web基础知识

HTTP协议是对请求/响应内容的规范

请求/响应都是静态文本，string类型，响应回的内容只能是HTML，表示静态资源

响应码

• 200：正常
• 404：未找到资源
• 500：服务器内部错误

Servlet: 接受并处理请求request；响应结果，服务端的控制器

JSP: 返回一个网页

Tomcat(容器)：一个开源小型好用的web应用服务器（用来运行JSP和Servlet）

tomcat添加

Tomcat启动失败问题

创建一个Servlet

1、将tomcat包下servlet依赖导入项目指定lib目录下

右键new还是没有servlet则在File-->project struct中找到Modules栏勾选最下方Source Roots，先点apply应用设置，再点close关闭

2、新建一个servlet项目

xxxxxxxxxx
package edu.ustb.controller;

              
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.IOException;
import java.io.PrintWriter;

              
@WebServlet(name = "HelloServlet", value = "/HelloServlet")
public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        PrintWriter out = response.getWriter();
        out.write("myfirst Servlet app!");
        out.flush();
        out.close();
    }

              
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

              
    }
}

response.getWriter()返回的是PrintWriter，这是一个打印输出流

• response.getWriter().writer(),只能打印输出文本格式的（包括html标签），不可以打印对象
• response.getWriter().print(),不仅可以打印输出文本格式的（包括html标签），还可以将一个对象以默认的编码方式转换为二进制字节输出

fush：输出缓冲

• flush是把流里的缓冲数据输出，flush以后还能继续使用这个OutputStream
• close是把这个流关闭了，也就是说以后这个OutputStream就不能用了，不过关闭之前会把缓冲的数据都输出

实现取出数据到页面中

报错：Cannot resolve method 'getResourceAsStream' in 'Resources'导入apach下的包而不是javax

Servlet的访问 eg: http://localhost:9527/ustb01/test.jsp

其根目录是Web目录

1、编写service层的读取数据库数据的类ShopInfoService

xxxxxxxxxx
package edu.ustb.service;

              
import edu.ustb.dao.ShopInfoMapper;
import edu.ustb.entity.ShopInfo;
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 java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;

              
public class ShopInfoService {

              
    public ArrayList<ShopInfo> getAll() {

              
        ArrayList<ShopInfo> list = null;
        try {
            InputStream inputStream = Resources.getResourceAsStream("edu/ustb/mybatis-config.xml");
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            SqlSession session = sqlSessionFactory.openSession();

              
            ShopInfoMapper siMapper = session.getMapper(ShopInfoMapper.class);
            list = siMapper.selectAll();
        }catch (IOException e){
            e.printStackTrace();
        }

              
        return list;
    }

              
}

2、编写控制端Servlet服务

这里调用Service层的方法读取数据，并将数据放入request域中。request域是在Service层以及web端都可以被访问的域，因此将数据放入该域可以发送request以及response请求到index界面，但request仅在当前请求有效。

这里的Servlet服务的值是/hello，因此在后续查看的时候应该查看hello端口，而不是index初始端口

xxxxxxxxxx
package edu.ustb.controller;

              
import edu.ustb.entity.ShopInfo;
import edu.ustb.service.ShopInfoService;

              
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 java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;

              
@WebServlet(name="HelloServlet",value="/hello")
public class HelloServlet extends HttpServlet {
    ShopInfoService shopInfoService = new ShopInfoService();

              
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{
        //获取列表数据
        ArrayList<ShopInfo> list = shopInfoService.getAll();
        //将列表存储到request域中
        //一个请求会创建一个reques对象，如果在一个请求中经历了多个Servlet，那么多个Seret可以使用request来共享数据。
        request.setAttribute("siList",list);
        //将请求转发到jsp页面
        request.getRequestDispatcher("/index.jsp").forward(request,response);
    }

              
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{

              
    }
}

3、页面端的接收数据：

xxxxxxxxxx
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
  <title>$Title$</title>
  <h1>商品列表</h1> <!-- 添加标题 -->
  <style>
    h1 {
      text-align: center;
    }
  </style>
</head>
<body>
<div>

              
  <table>
    <tr>
      <th>编号</th>
      <th>商品名称</th>
      <th>颜色</th>
    </tr>
    <c:forEach items="${siList}" var="si">
      <tr>
        <td>${si.shopId}</td>
        <td>${si.shopName}</td>
        <td>${si.color}</td>
      </tr>
    </c:forEach>
  </table>
</div>
</body>
</html>

Day 4

新构建Mybatis工具类，包含Session工厂的建立与session的返回

xxxxxxxxxx
package edu.ustb.utils;

              
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 java.io.InputStream;
import java.sql.SQLException;

              
public class MybatisUtil {
    private static SqlSessionFactory sqlSessionFactory;
    static{
        try{
            InputStream inputStream = Resources.getResourceAsStream("edu/ustb/mybatis-config.xml");
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

              
    public static SqlSession getSesseion() throws SQLException{
        return sqlSessionFactory.openSession();
    }
}

static代码块，在加载类的时候自动初始化（执行该代码块内内容），只能在该类被加载的时候执行一次

Service层的重构，使用Mybatis工具类更简单的调用Mybatis，以及溯源异常并抛出，最后保证session的释放

xxxxxxxxxx
package edu.ustb.service;

              
import edu.ustb.dao.ShopInfoMapper;
import edu.ustb.entity.ShopInfo;
import edu.ustb.utils.MybatisUtil;
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 java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;

              
public class ShopInfoService {
    /*
    * 返回所有商品
    * @return list
    * */
    public ArrayList<ShopInfo> getAll() {
        ArrayList<ShopInfo> list = null;
        SqlSession session = null;
        try {
            session = MybatisUtil.getSesseion();   //新构建的Mybatis的工具类完成session工厂的建立与返回session
            ShopInfoMapper siMapper = session.getMapper(ShopInfoMapper.class);
            list = siMapper.selectAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {   //finally字段保证即使出现错误，也将执行完该代码块
            if(session!=null){
                session.close();
            }
        }
        return list;
    }
}

分页查询

1、在dao层新增对于数据库的分页查找mysql语句，并利用@param进行参数绑定

xxxxxxxxxx
@Select("select * from shopinfo limit #{begin}, #{count}")
    public ArrayList<ShopInfo> selectByPage(@Param("begin") int begin, @Param("count") int count);  //@Param注解用于标注参数映射到哪个名字

2、声明一个pageBean类，用于存储有关于页面信息的数据，例如每页条目数，查询第几页，etc

这里使用了泛式编程，方便之后利用该范式存储不同类型的数据进行分页查询

xxxxxxxxxx
package edu.ustb.utils;

              
import java.util.List;

              
public class PageBean <T>{  //T泛型类似CPP泛式编程
    //当前页数
    private int pageIndex;
    //每页记录数
    private int pageRecord;
    //总页数
    private int pageCount;
    //总记录数
    private int totalRecord;

              
    private List<T> resultList;

              
    public int getPageIndex() {
        return pageIndex;
    }

              
    public void setPageIndex(int pageIndex) {
        this.pageIndex = pageIndex;
    }

              
    public int getPageRecord() {
        return pageRecord;
    }

              
    public void setPageRecord(int pageRecord) {
        this.pageRecord = pageRecord;
    }

              
    public int getPageCount() {
        return pageCount;
    }

              
    public void setPageCount(int pageCount) {
        this.pageCount = pageCount;
    }

              
    public int getTotalRecord() {
        return totalRecord;
    }

              
    public void setTotalRecord(int totalRecord) {
        this.totalRecord = totalRecord;
    }

              
    public List<T> getResultList() {
        return resultList;
    }

              
    public void setResultList(List<T> resultList) {
        this.resultList = resultList;
    }
}

3、在业务层(service)进行计算，连接控制层以及dao层，从控制层读取需要查询的页面数以及每页条目数，通过计算并调用dao层的查询结果，保存结果在pageBean的resultLIst中

xxxxxxxxxx
   public PageBean<ShopInfo> getPage(PageBean<ShopInfo> pageBean) {
        SqlSession session = null;
        try {
            session = MybatisUtil.getSesseion();   //新构建的Mybatis的工具类完成session工厂的建立与返回session
            ShopInfoMapper siMapper = session.getMapper(ShopInfoMapper.class);

              
            int begin = (pageBean.getPageIndex()-1)*pageBean.getPageRecord();

              
            pageBean.setResultList(siMapper.selectByPage(begin,pageBean.getPageRecord()));
        }catch (Exception e){
            e.printStackTrace();
        }finally {   //finally字段保证即使出现错误，也将执行完该代码块
            if(session!=null){
                session.close();
            }
        }
        return pageBean;
    }

4、控制层，完成从web端接受、解析请求，并执行，最后将结果返回web端的功能。

接收到分页查询需求，并得到参数p的值。调用业务层的分页查询方法，并得到返回的resultList，放入request域中，展示在web端

xxxxxxxxxx
@WebServlet(name="HelloServlet",value="/hello")
public class HelloServlet extends HttpServlet {
    ShopInfoService shopInfoService = new ShopInfoService();

              
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{
        //获取列表数据
        //ArrayList<ShopInfo> list = shopInfoService.getAll();

              
        String p = request.getParameter("p");  //读取参数
        int page = 1;    //默认参数为1
        try{
            page = Integer.parseInt(p);   //检查参数是否是整数
        }catch(Exception e){
            e.printStackTrace();
        }

              
        PageBean<ShopInfo> pageBean = new PageBean<ShopInfo>();
        pageBean.setPageIndex(page);
        pageBean.setPageRecord(20);
        pageBean = shopInfoService.getPage(pageBean);

              
        //将列表存储到request域中
        request.setAttribute("siList",pageBean.getResultList());
        //将请求转发到jsp页面
        request.getRequestDispatcher("/index.jsp").forward(request,response);
    }

              
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{

              
    }
}

利用url传参，例如

xxxxxxxxxx
http://localhost:8080/test_war_exploded/hello?p=2

设计底部页面导航栏

方式一：

手动添加页

仅需要在底部增加跳转超链接即可

xxxxxxxxxx
 <div>
<%--这里的hello使用的是相对路径--%>
    <a href="hello">1</a>
    <a href="hello?p=2">2</a>
    <a href="hello?p=3">3</a>
    <a href="hello?p=4">4</a>
  </div>

方式二：

自动生成页码，可根据数据条目数变化

1、需要知道一共有多少条数据，相应sql语句如下

xxxxxxxxxx
select count(1) from shopinfo;

1的用意是在查询结果每一行后都新增一个1，count只用计数1的个数，猜测这里使用了规约算法快速统计

因此在dao层添加相应的条目数查询语句

xxxxxxxxxx
@Select("select count(1) from shopinfo")
    public int selectCount();

需要在MybatisTest中进行测试dao层能否正确的取回条目数

2、业务层需要完善PageBean实例的其余参数设置，通过调用dao层的查询条目数，完善totalCount参数的设置，之后通过必要的计算得到相应的页面数，返回pageBean实例回控制层

xxxxxxxxxx
public PageBean<ShopInfo> getPage(PageBean<ShopInfo> pageBean) {
        SqlSession session = null;
        try {
            session = MybatisUtil.getSesseion();   //新构建的Mybatis的工具类完成session工厂的建立与返回session
            ShopInfoMapper siMapper = session.getMapper(ShopInfoMapper.class);
            //获取总记录数
            pageBean.setTotalRecord(siMapper.selectCount());
            //计算总页数
            if(pageBean.getTotalRecord() % pageBean.getPageRecord() == 0){
            pageBean.setPageCount(pageBean.getTotalRecord() / pageBean.getPageRecord());
            } else {
                pageBean.setPageCount(pageBean.getTotalRecord() / pageBean.getPageRecord() + 1);
            }
            //计算表中其实条目
            int begin = (pageBean.getPageIndex()-1)*pageBean.getPageRecord();

              
            pageBean.setResultList(siMapper.selectByPage(begin,pageBean.getPageRecord()));
        }catch (Exception e){
            e.printStackTrace();
        }finally {   //finally字段保证即使出现错误，也将执行完该代码块
            if(session!=null){
                session.close();
            }
        }
        return pageBean;
    }

3、相应的在控制层需要修改，此时传递给web端的不再是resultList了，而是pageBean，包含了所有的page信息

4、web端由于接受到的变成pageBean，所以需要读取的是其中的resultList成员，并且循环产生超链接

底部导航栏代码的变动

xxxxxxxxxx
<div>
<%--这里的hello使用的是相对路径--%>
<%--    <a href="hello">1</a>--%>
<%--    <a href="hello?p=2">2</a>--%>
<%--    <a href="hello?p=3">3</a>--%>
<%--    <a href="hello?p=4">4</a>--%>
    <c:forEach begin="1" end="${pageData.pageCount}" var="i">
      <a href="hello?p=${i}">${i}</a>
    </c:forEach>
  </div>

摇乐购工程创建

1、创建module

File->new->module，设置相应的名字，路径，这里命名为yaolegou，后续操作均在yaolegou模块下进行

2、添加框架

右键yaolegou，Add Framework Support，勾选Web Application和web.xml，并点击OK

3、添加依赖

在web/WEB-INF中创建lib目录(Directory)，在File->Project Structure中，侧栏选择Modules，选择yaolegou项目，添加依赖(Dependencies) 选择创建的lib目录路径，依赖类型是Jar Directory。最后将前三天工程lib下的依赖包复制移入该路径下，完成依赖的设置

4、导入页面文件

将yaolegou-页面文件内所有全部复制到web目录下

5、设置Tomcat

左上角加号后选择Tomcat Server里的Local

修改名字以和之前项目的tomcat区分，也可以删除之前项目的tomcat，笔者选择设置名字为tomcat

点击右下角的fix添加artifacts

点击+，artifacts，选择添加本项目的，名字为yaolegou的那一项

同时此时可以修改后续访问的url名，不喜欢_war_exploded后缀可以删除。选择Apply应用，ok确定

6、重定向初始界面

由于Tomcat默认index.jsp为首页，这里我们删除原本的index.jsp，使用名为ShouYe的页面为首页，有多种方法重定向，笔者选择修改WEB-INF下的web.xml文件，添加初始页面

xxxxxxxxxx
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <welcome-file-list>
        <welcome-file>ShouYe.jsp</welcome-file>
    </welcome-file-list>
</web-app>

7、设置一些包

在edu.ustb.manager路径下依次new出controller、dao、entity、service、test、utils

8、设置mybatis-config.xml

在edu.ustb.manager路径下直接new，内容从上一个工程复制，注意修改mapper路径

xxxxxxxxxx
<?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="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/yaolegoudb?useSSL=false&amp;allowPublicKeyRetrieval=true&amp;serverTimezone=GMT%2B8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
                <!--此处要修改-->
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <package name="edu/ustb/manager/dao"/>
    </mappers>
</configuration>

Mybatis分页插件PageHelper

Day 5

摇乐购项目

摇乐购项目广告轮播实现

1、新建entity下的Banner类

需要和mysql table中的名字一致方便调试

xxxxxxxxxx
    private int id;
    private String image;
    private String bgColor;
    private String href;
    private int isTingYong;
    private String beiZhu;
    private Date CreateTime;

右键生成get set方法，为了方便调试也可以生成toString方法

2、新建dao下BannerMapper接口(Interface)

从之前项目复制即可，注意读取的是banner表而不是shopinfo表

xxxxxxxxxx
public interface BannerMapper {
    @Select("select * from banner")
    public ArrayList<Banner> selectAll();
}

3、业务层Service，service下的BannerService类实现业务层的功能

同样从之前项目复制，这里变为Banner类即可

xxxxxxxxxx
public class BannerService {
    public ArrayList<Banner> getAll() {
        ArrayList<Banner> list = null;
        SqlSession session = null;
        try {
            session = MybatisUtil.getSesseion();   //Mybatis的工具类完成session工厂的建立与返回session
            BannerMapper bannerMapper = session.getMapper(BannerMapper.class);
            list = bannerMapper.selectAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {   //finally字段保证即使出现错误，也将执行完该代码块
            if(session!=null){
                session.close();
            }
        }
        return list;
    }
}

这里出现了MybatisUtil，因此我们直接从之前项目复制写好的工具类丢入utils package下

MybatisUtil工具类注意复制时修改resources路径为本项目路径，eg：edu/ustb/manager/mybatis-config.xml

4、实现Servlet，控制层命名为IndexServlet

右键new->servlet，如果右键没有请在project structure中勾选本项目的source root

这里将ShouYe.jsp重命名为Index.jsp相应的Day04中修改的默认主页也要相应改成Index.jsp

根据之前项目仿写

xxxxxxxxxx
@WebServlet(name = "IndexServlet", value = "/IndexServlet")
public class IndexServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //过滤器,过滤非法字符
        //暂未实现
        BannerService bannerService = new BannerService();
        //获取数据
        ArrayList<Banner> list = bannerService.getAll();
        //放入request域
        request.setAttribute("BannerList", list);
        //请求转发
        request.getRequestDispatcher("/Index.jsp").forward(request,response);
    }

              
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

              
    }
}

需要记住的是这里我们将轮播广告的信息list命名为BannnerList，因此接下来需要查找Index.jsp中的BannerList，而不是list

5、Index.jsp的修改

目前已经实现了将BannerList发送至web端，因此这里需要修改相关信息与list中的成员名一致，即一步骤实现的成员名

ctrl+F查找到轮播广告区块

xxxxxxxxxx
<!-- 轮播广告 -->
        <div id="banner_tabs" class="flexslider">
            <ul class="slides">
                <c:forEach var="banner" items="${BannerList}">
                    <c:if test="${banner.isTingYong == 0 }">
                        <li>
                            <a title="" target="_blank" href="${banner.href}">
                                <img width="1920" height="339" alt="" style="background: url(${banner.image}) no-repeat center;background-size:1200px">
                                <div style="background: ${banner.bgColor}" id="color"></div>
                            </a>
                        </li>
                    </c:if>
                </c:forEach>
            </ul>
            <ul class="flex-direction-nav">
                <li><a class="flex-prev" href="javascript:;">Previous</a></li>
                <li><a class="flex-next" href="javascript:;">Next</a></li>
            </ul>
            <ol id="bannerCtrl" class="flex-control-nav flex-control-paging">
                <c:forEach var="banner" items="${BannerList}">
                    <c:if test="${banner.isTingYong == 0 }">
                        <li><a>1</a></li>
                    </c:if>
                </c:forEach>
            </ol>
        </div>

6、纠错

如果网页不能正确显示相应图片，需要进行纠错

在test package下新建MybatisTest类并编写以下程序，前提是在第一步骤中自动生成了toString()方法

xxxxxxxxxx
public class MybatisTest {
    private SqlSession session = null;

              
    @Before
    public void Before() throws IOException {
        InputStream inputStream = Resources.getResourceAsStream("edu/ustb/manager/mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        session = sqlSessionFactory.openSession();
    }

              
    @Test
    public void TestSelectAll() throws IOException{
        BannerMapper bannerMapper = session.getMapper(BannerMapper.class);
//dao层的实现
        ArrayList<Banner> list = bannerMapper.selectAll();
        System.out.println(list.toString());
    }

              
    @After
    public void After() throws IOException{
        session.close();
    }
}

右键TestSelectAll()方法进行测试，如果能正确输出相关信息

那么说明dao层及以前层都正确，问题出在Service层Servlet层或者jsp层

• Service层需要检查MybatisUtil工具类编写的源路径是否正确
• Servlet层检查是否发送到正确的页面，eg /Index.jsp or /index.jsp，检查页面的拼写正确
• jsp层需要检查成员拼写是否与第一步骤中一致，BannerList拼写是否与Servlet层中发送到request域的一致，需要注意三点是可以点开的，可以复制步骤一中拼写直接覆盖。
• 查看结果的时候因为Servlet实现的端口位于/IndexServlet，因此查看的url地址为：localhost:8080/yaolegou/IndexServlet
• 目前应该只能实现两种图片轮播，不过观察到文件中存在Banner3.jpg，因此修改数据库banner中第三行的img路径最后图片名为Banner3.jpg就可以实现三张图片轮播，之后不断增加数据库与文件夹image/index_image/中的图片就可以实现轮播广告的扩增

摇乐购项目登录功能实现

ajax异步请求，完成请求功能，优点略

jquery框架，封装好JS的框架

1、声明user类用于存放用户信息

xxxxxxxxxx
private int id;
private String userName;
private String password;
private int state;
private Date CreateTime;
private String userNick;

并生成相应的set&get方法以及toString方法用于测试

2、写出对应的dao层

根据用户名查询单条用户信息，这里用了表连接的方法同时查询两张表

xxxxxxxxxx
public interface UserMapper {
    @Select("select u.*, ui.UserNick  from user u INNER JOIN userinfo ui on u.Username = ui.UserName where u.username = #{username}")
    public User selectName(@Param("username") String userName);
}

3、在业务层进行判断，并且返回判断信息

这里的返回信息需要和Index.jsp里面的判断条件相一致才能完成跳转以及弹窗

xxxxxxxxxx
public class UserService {
    /**
     * 判断登录信息是否正确，并返回对应的判断结果
     * @return String
     */
    public String login(User user) {
        SqlSession session = null;
        String result = "";  //进行登录信息校验
        try {
            session = MybatisUtil.getSesseion();   //Mybatis的工具类完成session工厂的建立与返回session
            UserMapper userMapper = session.getMapper(UserMapper.class);
            User u = userMapper.selectName(user.getUserName());

              
            if(u == null){
                result = "dongjie";
            }
            else if(!user.getPassword().equals(u.getPassword())){   //比较输入密码和数据库密码是否一致，这里是能使用equals方法比较字符串而不能使用==
                result = "beijing";  //密码错误请重新输入
            }
            else {
                result = "true";
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {   //finally字段保证即使出现错误，也将执行完该代码块
            if(session!=null){
                session.close();
            }
        }
        return result;
    }
}

4、控制层功能实现

这里为了方便与IndexServlet写在一起，原理：Banner广告展示只用了get方法，而不是用post方法，而登录信息只是用了post方法，这样写只是为了方便，但是实际妨碍后期调试

xxxxxxxxxx
@Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //处理登录功能
        request.setCharacterEncoding("utf-8");   //设置编码
        response.setCharacterEncoding("utf-8");
        UserService userService = new UserService();

              
        //登录
        String name = request.getParameter("UserName");  //从文本框拿到对应数据
        String pwd = request.getParameter("PassWord");

              
        User user = new User();
        user.setUserName(name);
        user.setPassword(pwd);

              
        //调用service校验账户信息
        String result = userService.login(user);

              
        //将结果写回客户端，即作为回调函数的参数
        PrintWriter out = response.getWriter();
        out.write(result);
        out.flush();
        out.close();
    }

5、web端

这里需要修改请求的端口与实现的一致，具体端口名是实现相应功能Servlet的val值

因此需要修改如下，这里笔者将成功登录后的页面设置为跳转回首页，具体可以根据喜好更改

xxxxxxxxxx
<script type="text/javascript">
        $(function (){
            $("#tijiao").click(function (){
                //获取用户名和密码
                var UserName = $("[name=UserName]").val();
                var PassWord = $("[name=PassWord]").val();
                //执行异步请求
                $.post("IndexServlet",{"UserName":UserName,"PassWord":PassWord},function (Data){
                    if(Data == "true"){
                        //加载页面
                        window.open("IndexServlet","_self");  //此处的端口是登录成功后的端口
                    }else if(Data == "dongjie"){
                        $("#text").html("您的账号已违规法律暂被停用！");
                        $("#beijing").fadeIn("300");
                    }else{
                        $("#beijing").fadeIn("300");
                    }
                })
            })
            
            //关闭提示背景
            $("#beijing").click(function (){
                $(this).fadeOut("300");
                setTimeout(3,function (){
                    alert();
                    $("#beijing").fadeOut("300");
                });
            })
        })
    </script>

6、调试

在MybatisTest中同样编写TestUserSelectAll()方法来测试能否通过用户名从数据库提取出相应用户信息

xxxxxxxxxx
/*测试用户密码从数据库读取正确性
     *@return null
     **/
    @Test
    public void TestUserSelectAll() throws IOException{
        UserMapper userMapper = session.getMapper(UserMapper.class);
        String userName = "1234567";
        User user = userMapper.selectName(userName);
        System.out.println(user);
    }

如果能正确输出，表示数据库到dao层没有问题。

此时打开网页，按f12打开控制台，查看控制台的输出来确定错误位置

登陆后显示用户名实现

request域仅能在当前请求存在，如果跳转则请求不存在。因此引入 ？会话域？ (未引入)

1、在业务层新增返回user类的方法

xxxxxxxxxx
public User getUserByName(String userName) {
        SqlSession session = null;
        User user = null;
        try {
            session = MybatisUtil.getSesseion();   //Mybatis的工具类完成session工厂的建立与返回session
            UserMapper userMapper = session.getMapper(UserMapper.class);
            user = userMapper.selectName(userName);
        }catch (Exception e){
            e.printStackTrace();
        }
        return user;
    }

2、Servlet层

新增如果校验结果为true，则加载user信息，并将user类放入request域中命名为user

xxxxxxxxxx
if("true".equals(result)) {  //这样写不会报空指针错误
            //加载user数据
            user = userService.getUserByName(user.getUserName());
            //登录成功将用户信息放入user
            request.getSession(true).setAttribute("user",user);
        }

3、web端

在jsp页面中找到相应位置，修改命名与控制层一致

xxxxxxxxxx
<ul  class="daohang" style="float:right">
                    <%-- <c:set var="student" value="1" scope="session"></c:set> --%>
                    <c:if test="${ empty user}">
                        <li class="login_DengLu" id="denglu">您好，请登录</li>
                    </c:if>
                    <c:if test="${ not empty user}">
                        <li class="xia">${user.userNick}
                            <div class="div_wzdh" onmouseout="wzfl_lk()">
                                <a href="LeGou.do?UserName=${user.userName}" target="_black">个人管理</a>
                                <a href="LeGou.do?State=Exit">退出账号</a>
                            </div>
                        </li>
                    </c:if>

登录效果：

卷王任务：

1、登录功能基础上列表页，加上分页

2、手机短信校验流程

WeeK 2

Day 1

完成用户手机验证注册功能

1、导入相应依赖jar包

略

2、补全User类成员

User类应该包含两张表的内容

xxxxxxxxxx
    private int id;
    private String userName;
    private String password;
    private int state;
    private Date CreateTime;
    private String userNick;
    private String phone;
    private String image;

3、编写dao层接口

复制粘贴之前的实现

xxxxxxxxxx
@Select("select u.*, ui.UserNick from user u INNER JOIN userinfo ui on u.Username = ui.UserName where u.username = #{username}")
    public User selectName(@Param("username") String userName);

              
    @Select("select u.*, ui.UserNick from user u INNER JOIN userinfo ui on u.Username = ui.UserName where ui.phone = #{phone}")
    public User selectByPhone(@Param("phone") String phone);

              
    @Insert("INSERT INTO user (UserName,PassWord,State) "
            +" VALUES (#{userName},#{password},#{state})")
    public int insertUser(User user);

              
    @Insert("INSERT INTO userinfo (username,usernick,phone,sexid,isdianpu,money,dianpumoney,image)"
            +" VALUES (#{userName},#{userNick},#{phone},3,0,0,0,#{image})")
    public int insertUserInfo(User user);

4、编写工具类CheckCodeUtil

用来随机生成验证码的复制工具类位于utils包下

xxxxxxxxxx
public class CheckCodeUtil {
    /**
     * @param len 位数
     * @return
     */

              
    public static String getCode(int len) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; sb.length() < len; i++) {
            int num = new Random().nextInt(10);
            sb.append(num);
        }
        return sb.toString();
    }
}

5、编写Service层UserService

UserService类中需要额外添加如下方法

xxxxxxxxxx
/**
     *用于通过用户名查询用户信息
     * @param userName 用户姓名
     * @return 用户类
     */
    public User getUserByName(String userName) {
        SqlSession session = null;
        User user = null;
        try {
            session = MybatisUtil.getSesseion();   //Mybatis的工具类完成session工厂的建立与返回session
            UserMapper userMapper = session.getMapper(UserMapper.class);
            user = userMapper.selectName(userName);
        }catch (Exception e){
            e.printStackTrace();
        }
        return user;
    }

xxxxxxxxxx
/**
     *用于添加用户
     * @param user 用户信息
     * @return int 是否成功
     */
    public int userAdd(User user){
        SqlSession session = null;
        int result = 0;
        try {
            session = MybatisUtil.getSesseion();
            user.setImage("attached/TouXiang/default.gif");
            UserMapper userMapper = session.getMapper(UserMapper.class);
            result = userMapper.insertUser(user);
            result += userMapper.insertUserInfo(user);
            session.commit();
        }catch (Exception ex){
            ex.printStackTrace();
            session.rollback();
            result = 0;
        }finally {
            session.close();
        }
        return result;
    }

xxxxxxxxxx
/**
     *通过手机号查询用户，在注册时验证改用户是否被注册过
     * @param phone 用户电话
     * @return 用户类
     */
    public User getUserByPhone(String phone) {
        SqlSession session = null;
        User user = null;
        try {
            session = MybatisUtil.getSesseion();   //Mybatis的工具类完成session工厂的建立与返回session
            UserMapper userMapper = session.getMapper(UserMapper.class);
            user = userMapper.selectByPhone(phone);
        }catch (Exception e){
            e.printStackTrace();
        }
        return user;
    }

下面代码中需要填写自己的KeyID，Key，签名名称，模板CODE，需要在阿里云官网查看，此处不赘述如何查看

xxxxxxxxxx
/**
     * 向目标手机号发送目标验证码
     * @param phone 用户手机号
     * @param code 生成的验证码
     * @return 包含是否成功发送的json
     */
    public String sendSms(String phone, String code) {
        String result = null;
        /********************此处需要设置为自己的accessKeyId和secret*********************************/
        DefaultProfile profile = DefaultProfile.getProfile("cn-hangzhou", "YOUR ACCESSKYEID", "YOUR SECRET");
        IAcsClient client = new DefaultAcsClient(profile);
        CommonRequest request = new CommonRequest();

              
        request.setMethod(MethodType.POST);//注意这四行，与官网所展示的方法不同
        request.setDomain("dysmsapi.aliyuncs.com");
        request.setVersion("2017-05-25");
        request.setAction("SendSms");
        request.putQueryParameter("RegionId", "cn-hangzhou");
        request.putQueryParameter("PhoneNumbers", phone);
        request.putQueryParameter("SignName", "你的签名名称");
        request.putQueryParameter("TemplateCode", "你的模板CODE");
        request.putQueryParameter("TemplateParam", "{\"code\": "+ code +" }");

              
        try {
            CommonResponse response = client.getCommonResponse(request);
            result = response.getData();
        } catch (ServerException e) {
            e.printStackTrace();
        } catch (ClientException e) {
            e.printStackTrace();
        }
        return result;
    }

6、编写control层UserServlet

这里首先需要修改相应端口为reg，因此后续web端中所有请求应该向reg请求而不是ZhuCe.do

xxxxxxxxxx
@WebServlet(name = "UserServlet", value = "/reg")
public class UserServlet extends HttpServlet {

              
    UserService userService = new UserService();

              
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        /*PrintWriter out = response.getWriter();*/
        request.setCharacterEncoding("utf-8");
        response.setCharacterEncoding("utf-8");
        response.setContentType("text/html;charset=UTF-8");

              
        String State = request.getParameter("State");
        String phone = request.getParameter("phone");
        if(State == null){
            request.setAttribute("phone", phone);
            request.getRequestDispatcher("/reg2.jsp").forward(request, response);
        }else if(State.equals("add")){
            //获取手机号和密码
            String pwd = request.getParameter("pwd");

              
            //生成八位随机数
            Random random = new Random();
            int suiji = random.nextInt(99999999);
            String UserName = suiji+"";

              
            //赋值
            User u = new User();
            u.setUserName(UserName);
            u.setPassword(pwd);
            u.setPhone(phone);

              
            //随机生成网名
            String[] name1 = new String[]{"最帅的","好看的","美丽的","会撩妹的","爱玩快手的","可爱的","爱听音乐的","爱斗图的","细心的","爱玩抖音的"};
            String[] name2 = new String[]{"小红","小仙女","小清新","郭德纲","小白","翠花","熊大","熊二","光头强","老崔"};
            int n1 = random.nextInt(10);
            int n2 = random.nextInt(10);
            String UserNick = name1[n1]+name2[n2];

              
            u.setUserNick(UserNick);

              
//       //执行增加用户
//       boolean is = ud.AddUserNameInfo(u);
            
            /*****************************重点区域***************************************/
            userService.userAdd(u);
            //此处的State状态由前端传输得到
            response.getWriter().print(UserName);
        }else if(State.equals("yanzhengs")){                    //此处是前端当不聚焦于电话对话框是，就会向后端请求yanzhengs，用于确定电话号是否有效          
            User user = userService.getUserByPhone(phone);
            response.getWriter().print(user == null);
        }else if(State.equals("sendsms")){                      //此处是按下发送验证码的按钮时向后端请求，作用是随机生成验证码并且发送验证码短信给目标手机号
            String code = CheckCodeUtil.getCode(6);
            String result = userService.sendSms(phone, code);
            ObjectMapper objMapper = new ObjectMapper();
            Map <String, String> rst = objMapper.readValue(result, Map.class);
            if("OK".equals(rst.get("Code"))){                   //如果成功发送验证短信，此时将生成的验证码存储于request域中，以便检查用户输入是否一致
            //if("OK".equals(result)){
                request.getSession().setAttribute("smsCode", code);
                response.getWriter().print("true");
            }
        }else if(State.equals("checksms")){                     //当前端点击注册按钮时且验证码blank不为空的时候，将发起该请求，进行验证码输入与生成的对比
            String code = request.getParameter("smscode");
            boolean data = code.equals(request.getSession().getAttribute("smsCode"));
            response.getWriter().print(data);
        /*****************************重点区域***************************************/
        }
    }

              
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }
}