SSM入门参考文档-暑假集训

• MyBatis框架

1. MyBatis简介

MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。

 

1. MyBatis框架的搭建与相关知识点介绍

1. 导入jar包(MyBatis和数据库驱动)
2. 创建MyBatis框架的配置文件(核心配置文件)

<?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:配置MyBatis运行的环境-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>  <!--配置数据类型-->
            <!--配置连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/java"/>

                <property name="username" value="root"/>
                <property name="password" value="20153279lwq"/>

            </dataSource>
        </environment>
    </environments>

    <!--制定sql映射文件-->
    <mappers>
        <mapper resource="mapper/usermapper.xml"/>
    </mappers>
</configuration>

 

1. 创建mapper文件，该文件映射sql

<?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">

<!--namespace:命名空间，用于隔离sql语句-->
<mapper namespace="mapper.usermapper">
    <!--
        id:sql语句的唯一标识
        resultType:指定结果的类型（完成ORM映射）
    -->
    <select id="findUser" resultType="com.lb.UserBean">
        select * from user_info
    </select>
</mapper>

 

1. 创建代码读取配置文件，操作数据库

//创建读取MyBatis核心配置文件的输入流

InputStream cfg = Resources.getResourceAsStream("batiscfg.xml");

//创建SqlSessionFactory的构建器对象

SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

//调用构建器的build方法创建工厂对象

SqlSessionFactory sqlFac = builder.build(cfg);

//通过工厂创建对象

SqlSession sqlSession = sqlFac.openSession();

//通过SqlSession对象执行查询操作。参数：映射文件中对应的sql的id

UserBean user = sqlSession.selectOne("mapper.usermapper.queryOne");
System.out.println("user = " + user);
sqlSession.close();

1. MyBatis运行原理

1）通过SqlSessionFactoryBuilder 的对象，读取MyBatis核心配置文件中配置的信息。

2）创建连接池，开启事务管理，加载sql映射文件等等。

3）通过SqlSession 对象，去取MyBatis创建的连接池中的连接，通过该连接去完成增删改查的操作。

4）在执行增删改查的操作的时候，会去读取sql映射文件中的sql语句，进行实际的数据库操作。

 

（6）MyBatis核心配置文件的标签

<?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>
    <!--
        properties:定义一系列的属性（相当于代码中定义很多个变量）
        resource属性：引用外部的文件定义属性（properties）
    -->
    <properties resource="mysql.properties">
        <!--
            properties:具体定义一个属性
            name：属性的名字
            value:属性的值
        -->
        <property name="mdriver" value="com.mysql.jdbc.Driver"/>
        <property name="dbUrl" value="http://www.baidu.com"/>
        <!--
            使用properties标签所定义的属性：$｛属性名｝
         -->
        <!--
            当properties引用的外部属性名和内部标签定义的属性名相同的时候，MyBatis取外部的属性文件中的值
        -->
    </properties>

    <!--setting:具体设置每一个行为-->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>   <!--设置打开日志，value指定用哪个日志框架-->
        <setting name="lazyLoadingEnabled" value="true"/>   <!--设置MyBatis的延迟加载开关，打开-->
        <setting name="aggressiveLazyLoading" value="false"/> <!--设置是否延迟加载false延迟加载-->
    </settings>

    <!--
        typeAliases:给java类定义别名，方便使用
    -->
    <typeAliases>
        <!--
            typeAlias:具体指定某一个类的别名
            type:指定类
            alias:指定别名
        -->
        <typeAlias type="com.lb.UserBean" alias="user"/>
        <typeAlias type="com.lb.UserBean2" alias="user2"/>
        <!--package:给一个包中的类批量起别名（别名就是类名，也可以小写）-->
        <package name="com.lb"/>
        <!--当一个类有多个别名的时候，用任何一个均可-->
    </typeAliases>

    <!--environments:配置MyBatis运行的环境-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>  <!--配置数据类型-->
            <!--配置连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/java"/>
                <property name="username" value="root"/>
                <property name="password" value="20153279lwq"/>
            </dataSource>
        </environment>
    </environments>

    <!--制定sql映射文件-->
    <mappers>
        <mapper resource="mapper/usermapper.xml"/>
    </mappers>
</configuration>

 

 

 

（7）MyBatis实现数据库的增删改查

注意：

在执行insert update delete的时候，需要自己提交会话，结果才会在数据库中生效；

MyBatis在完成ORM映射的时候(根据查询的结果创建JavaBean对象)，调用的是JavaBean的无参构造；

1. 映射文件：

<?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="mapper.usermapper">

    <select id="queryOne" resultType="user">
        select * from userinfo where id=1
    </select>

    <!--
        #{} 相当于占位符，括号中的名字是参数名
    -->
    <select id="queryDynamic" resultType="user">
        select * from userinfo where id=#{mid}
    </select>

    <!--分页查询  HashMap封装数据-->
    <select id="queryPage" resultType="user">
        select * from userinfo limit #{offset},#{len}
    </select>

    <!--分页查询  RowBounds封装数据-->
    <select id="queryPage2" resultType="user">
        select * from userinfo limit #{offset},#{limit}
    </select>

    <!--模糊查询-->
    <!--
        select * from userinfo where name like '%j'; //以j为结尾
        select * from userinfo where name like 'j%'; //以j为开头
        select * from userinfo where name like '%j%'; //包含j
    -->
    <!--
        ${}:相当于是连接符
        参数名：当传入的是直接数据的时候，参数名是value
               当传入的是对象的时候，参数名是对象中的属性的名字
    -->
    <select id="queryLike" resultType="user">
        select * from userinfo where name like '%${value}%'
    </select>
</mapper>

 

1. 主代码：
   public class Main {
   
       public SqlSessionFactory getSessionFactory(){
           SqlSessionFactory fac = null;
           try {
               InputStream cfg = Resources.getResourceAsStream("batiscfg.xml");
               SqlSessionFactoryBuilder facBuilder = new SqlSessionFactoryBuilder();
               fac = facBuilder.build(cfg);
   
           } catch (IOException e) {
               e.printStackTrace();
           }
           return fac;
       }
   
       public void findOne(){
           SqlSessionFactory fac = getSessionFactory();
           SqlSession sqlSession = fac.openSession();
           UserBean user = sqlSession.selectOne("mapper.usermapper.queryOne");
           System.out.println("user = " + user);
       }
   
       public void findOneDynamic(){
           SqlSessionFactory fac = getSessionFactory();
           SqlSession sqlSession = fac.openSession();
           UserBean user = sqlSession.selectOne("mapper.usermapper.queryDynamic", 40);
           System.out.println("user = " + user);
       }
   
       public void findPage(){
           SqlSessionFactory fac = getSessionFactory();
           SqlSession sqlSession = fac.openSession();
           //把分页所需要的参数(offset和len)封装到一个HashMap中进行传递
           //注意：mapper中的sql的参数名要和HashMap中的key的名字一致
           HashMap<String, Integer> pageMap = new HashMap<String, Integer>();
           pageMap.put("offset", 0);
           pageMap.put("len", 3);
   
           List<UserBean> users = sqlSession.selectList("mapper.usermapper.queryPage", pageMap);
           System.out.println("users = " + users);
       }
   
       public void findPage2(){
           SqlSessionFactory fac = getSessionFactory();
           SqlSession sqlSession = fac.openSession();
           //RowBounds封装分页的参数的。参数一：偏移量  参数二：行数
           //注意：保证sql中的参数名跟RowBounds对象中的属性名要一致
           RowBounds pageData = new RowBounds(1, 4);
           List<UserBean> users = sqlSession.selectList("mapper.usermapper.queryPage2", pageData);
           System.out.println("users = " + users);
       }
   
       public void findLike(){
           SqlSessionFactory fac = getSessionFactory();
           SqlSession sqlSession = fac.openSession();
           List<UserBean> users = sqlSession.selectList("mapper.usermapper.queryLike", "ji");
           System.out.println("users = " + users);
       }
   
   }

 

注意：此时可以直接用junit4模块进行生产测试模块，直接在MainTest中测试。同时如果想要实现此功能，需要导入hamcrest-core-1.3.jar和junit-4.12.jar包；

 

（8）mapper的代理 

 

1. 原理介绍

在使用SqlSession的增删改查的方法的时候，都需要自己指定使用mapper文件中的哪一个sql语句，指定的时候需要正确的拼写出sql语句的id，这个操作比较麻烦而且容易出错。故希望把指定id的操作通过代理的方式交给代码处理。

1. 代码实现步骤

1. 在src中新建一个和mapper.xml同名的接口

把mapper.xml映射文件的namespace的值定义成接口的全限定名

在接口中定义和mapper.xml中的sql语句对应的方法，并且方法名要和sql的id一致

在定义方法的时候，应该保证方法的形参和parameterType的类型一致，方法的返回值和resultType的类型一致

通过代理接口实现mapper.xml映射文件中定义的数据库的操作

 

1. MyBatis框架的二次封装和动态sql的实现

1. 二次封装代码：

public class MyBatisUtils {
    private static SqlSessionFactory fac;
    private static SqlSession sqlSession;
    private static ThreadLocal<SqlSession> tLocal = new ThreadLocal<SqlSession>();

    //静态代码，在类已被加载的时候，就会执行，并且只会运行一次。
    static{
        try {
            InputStream cfg = Resources.getResourceAsStream("batiscfg.xml");
            SqlSessionFactoryBuilder facBuilder = new SqlSessionFactoryBuilder();
            fac = facBuilder.build(cfg);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    //定义一个方法用于返回SqlSession对象
    public static SqlSession getSession(){
        //多线程不安全问题，加锁问题，（多个线程访问同一个对象，会造成线程不安全问题）
        SqlSession sqlSession = tLocal.get();
        if(sqlSession == null){
            sqlSession = fac.openSession();
            tLocal.set(sqlSession);
        }
        return sqlSession;
    }

    //定义一个方法用于关闭SqlSession对象
    private static void closeSession(){
        sqlSession = tLocal.get();
        if(sqlSession != null){
            sqlSession.close();
            tLocal.remove();
        }
    }

2)动态SQL代码：

<?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">

<!--namespace:命名空间，用于隔离sql语句-->
<mapper namespace="com.lb.mapper.UserMapper">

    <!--
        if标签:判定条件是否成立，来决定是否拼接sql
            test属性:指定属性
    -->
    <select id="findUser" resultType="com.lb.bean.UserBean">
        select * from user_info
        <if test="name != null">
            where name = #{name}
        </if>

    </select>

    <!--
        where标签：用于实现where子句的多个条件的拼接
        注意：where标签会自动把第一个查询条件中的and 或者是or去掉
     -->
    <select id="findWhere" resultType="user">
        select * from user_info
        <where>
            <if test="name != null">
                and name = #{name}
            </if>

            <if test="sex">
                and sex = #{sex}
            </if>
        </where>
    </select>

    <!--
        in操作符：select * from user_info where name in ("lwq","nancy","bob");
        foreach 遍历一组数据
        foreach标签:遍历多个值
    -->

    <select id="selectIn" resultType="user">
        select * from user_info where name in
        <foreach collection="list" open="(" close=")" separator="," item="name">
            #{name}
        </foreach>
    </select>
</mapper>

 

（10）MyBatis实现多表联查

user表：

 

role表：

 

代码实现：

1. 映射文件

<?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">

<!--namespace:命名空间，用于隔离sql语句-->
<mapper namespace="com.lb.mapper.UserMapper">

    <!--
        如果查询值与UserBean无法一一对应，需要用resultMap将其对应
        实现了多对一
    -->
    <resultMap id="roleMap" type="user">
        <result column="uid" property="uid"/>
        <result column="rid" property="rid"/>
        <result column="uname" property="uname"/>
        <!--
            association标签：构建java类对象和表中的列的对应关系
            property属性：用于指定bean中的属性的名字
        -->
        <association property="role" javaType="role">
            <result column="rid" property="rid"/>
            <result column="rname" property="rname"/>
        </association>
    </resultMap>

    <select id="findUser_Role" resultMap="roleMap">
        select * from user left join role on user.rid = role.rid
    </select>

    <!--
        实现一对多
    -->
    <resultMap id="userMap" type="role1">
        <result column="rid" property="rid"/>
        <result column="rname" property="rname"/>
        <!--collection标签：映射集合中的对象和结果中的列的对应关系-->
        <collection property="user1" ofType="user1">
            <result column="uid" property="uid"/>
            <result column="rid" property="rid"/>
            <result column="uname" property="uname"/>
        </collection>
    </resultMap>
    <select id="selectRole_User" resultMap="userMap">
        select * from role left join user on role.rid = user.rid
    </select>
</mapper>

 

1. UserBean文件

package com.lb.bean;

public class UserBean {

    private int uid;
    private int rid;
    private String uname;

    private RoleBean role;


    public int getUid() {
        return uid;
    }

    public void setUid(int uid) {
        this.uid = uid;
    }

    public int getRid() {
        return rid;
    }

    public void setRid(int rid) {
        this.rid = rid;
    }

    public String getUname() {
        return uname;
    }

    public void setUname(String uname) {
        this.uname = uname;
    }


    public RoleBean getRole() {
        return role;
    }

    public void setRole(RoleBean role) {
        this.role = role;
    }

    @Override
    /*
    toString 函数主要是将输出结果进行规范化，利用拼接技术
     */
    public String toString() {
        return "UserBean{" +
                "uid=" + uid +
                ", rid=" + rid +
                ", uname='" + uname + '\'' +
                ", rname=" + role.getRname() +
                '}';
    }

}

 

1. RoleBean文件

package com.lb.bean;

public class RoleBean {
    private int rid;
    private String rname;

    public int getRid() {
        return rid;
    }

    public void setRid(int rid) {
        this.rid = rid;
    }

    public String getRname() {
        return rname;
    }

    public void setRname(String rname) {
        this.rname = rname;
    }

    @Override
    public String toString() {
        return "RoleBean1{" +
                "rid=" + rid +
                ", rname='" + rname + '\'' +
                '}';
    }
}

 

（11）利用Servlet技术与MyBatis框架实现增删改查（作业）

Myjob表

 

1. batiscfg.xml配置文件

<?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>

    <!--
        typeAliases:给java类定义别名，方便使用
    -->
    <typeAliases>
        <typeAlias type="com.lb.bean.JobBean" alias="jobs"/>
        <package name="com.lb"/>
    </typeAliases>

    <!--environments:配置MyBatis运行的环境-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>  <!--配置数据类型-->
            <!--配置连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/java?characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="20153279lwq"/>
            </dataSource>
        </environment>
    </environments>

    <!--制定sql映射文件-->
    <mappers>
        <mapper resource="mapper/JobMapper.xml"/>
    </mappers>
</configuration>

 

1. JobMapper.xml映射文件

<?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="com.lb.mapper.JobMapper">
    <select id="findOne" resultType="jobs">
        select * from MyJob
        <where>
            <if test="job != null">
                and job = #{job}
            </if>
            <if test="job_address != null">
                and job_address = #{job_address}
            </if>
            <if test="re_sex != null">
                and re_sex = #{re_sex}
            </if>
        </where>
    </select>

    <select id="findAll" resultType="jobs">
        select * from MyJob
    </select>

    <delete id="deleteOne">
        delete from MyJob where id = #{id}
    </delete>

    <insert id="insertOne">
        insert into MyJob(job,job_address,re_sex) values(#{job},#{job_address},#{re_sex})
    </insert>

    <update id="updateOne">
        update MyJob set job = #{job},job_address = #{job_address},re_sex = #{re_sex}
        where id = #{id}
    </update>

</mapper>

 

1. JobBean文件

package com.lb.bean;

public class JobBean {
    private int id;
    private String job;
    private String job_address;
    private String re_sex;

    public JobBean() {
    }

    public JobBean(String job, String job_address, String re_sex) {
        this.job = job;
        this.job_address = job_address;
        this.re_sex = re_sex;
    }

    public JobBean(int id, String job, String job_address, String re_sex) {
        this.id = id;
        this.job = job;
        this.job_address = job_address;
        this.re_sex = re_sex;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    public String getJob_address() {
        return job_address;
    }

    public void setJob_address(String job_address) {
        this.job_address = job_address;
    }

    public String getRe_sex() {
        return re_sex;
    }

    public void setRe_sex(String re_sex) {
        this.re_sex = re_sex;
    }

    @Override
    public String toString() {
        return "JobBean{" +
                "id=" + id +
                ", job='" + job + '\'' +
                ", job_address='" + job_address + '\'' +
                ", re_sex='" + re_sex + '\'' +
                '}';
    }
}

 

1. JobMapper接口映射

package com.lb.mapper;

import com.lb.bean.JobBean;

import java.util.List;

public interface JobMapper {
    List<JobBean> findAll();

    List<JobBean> findOne(JobBean jobs);

    void updateOne(JobBean jobs);

    void deleteOne(int id);

    void insertOne(JobBean jobs);


}

 

1. MyBatisUtils封装文件
   
   public class MyBatisUtils {
       private static SqlSessionFactory fac;
       private static SqlSession sqlSession;
       private static ThreadLocal<SqlSession> tLocal = new ThreadLocal<SqlSession>();
   
       //静态代码，在类已被加载的时候，就会执行，并且只会运行一次。
       static{
           try {
               InputStream cfg = Resources.getResourceAsStream("batiscfg.xml");
               SqlSessionFactoryBuilder facBuilder = new SqlSessionFactoryBuilder();
               fac = facBuilder.build(cfg);
           } catch (IOException e) {
               e.printStackTrace();
           }
   
       }
   
       //定义一个方法用于返回SqlSession对象
       public static SqlSession getSession(){
           //多线程不安全问题，加锁问题，（多个线程访问同一个对象，会造成线程不安全问题）
           SqlSession sqlSession = tLocal.get();
           if(sqlSession == null) {
               sqlSession = fac.openSession();
               tLocal.set(sqlSession);
           }
           return sqlSession;
       }
   
       //定义一个方法用于关闭SqlSession对象
       public static void closeSession(){
           sqlSession = tLocal.get();
           if(sqlSession != null){
               sqlSession.close();
               tLocal.remove();
           }
       }
   
   }

 

1. Main文件（集中写sql调用函数）
   
   public class Main {
   
       public List<JobBean> queryAll(){
   
           SqlSession session = MyBatisUtils.getSession();
           JobMapper mapper = session.getMapper(JobMapper.class);
           List<JobBean> jobs =mapper.findAll();
           MyBatisUtils.closeSession();
           return jobs;
       }
   
       public List<JobBean> queryOne(JobBean job) {
           SqlSession session = MyBatisUtils.getSession();
           JobMapper mapper = session.getMapper(JobMapper.class);
           //JobBean jobs = new JobBean("服务员",null,"男");
           List<JobBean> jobInfo = mapper.findOne(job);
           MyBatisUtils.closeSession();
           return jobInfo;
       }
   
   
       public void insertOne(String job,String job_address,String re_sex){
           SqlSession session = MyBatisUtils.getSession();
           JobMapper mapper = session.getMapper(JobMapper.class);
           JobBean info = new JobBean(job,job_address,re_sex);
           mapper.insertOne(info);
           session.commit();
           MyBatisUtils.closeSession();
       }
   
       public void deleteOne(int id){
           SqlSession session = MyBatisUtils.getSession();
           JobMapper mapper = session.getMapper(JobMapper.class);
           mapper.deleteOne(id);
           session.commit();
           //由于涉及到多线程问题，当执行此操作后，需要返回到queryall，因此不能关闭session
           //解决方法：在MyBatisUtils中将sqlsession定义为局部的，不需要进行全局申明
           //或者是将他单独关闭，调用closeSession方法
           //session.close();
           MyBatisUtils.closeSession();
       }
   
       public void updateOne(int id,String job,String job_address,String re_sex){
           SqlSession session = MyBatisUtils.getSession();
           JobMapper mapper = session.getMapper(JobMapper.class);
           JobBean jobs = new JobBean(id,job,job_address,re_sex);
           mapper.updateOne(jobs);
           session.commit();
           MyBatisUtils.closeSession();
       }
   }

 

1. Find（查找的servlet文件）
   
   public class find extends HttpServlet {
       @Override
       protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
           String job = new String((req.getParameter("job")).trim().getBytes("ISO-8859-1"),"UTF-8");
           String job_address = new String((req.getParameter("job_address")).trim().getBytes("ISO-8859-1"),"UTF-8");
           String re_sex = new String((req.getParameter("re_sex")).trim().getBytes("ISO-8859-1"),"UTF-8");
   
           //System.out.println(job_address+"+"+re_sex);
   
   
           //因为sql语句使用<where>标签进行动态查询，所以此处需要分为三种情况考虑job_bean的拼装
           if(job == null || job.length()==0)
           {
               job = null;
           }
   
           if(job_address == null || job_address.length()==0)
           {
               job_address = null;
           }
   
           if(re_sex == null || re_sex.length()==0 || re_sex.length()>5)
           {
               re_sex = null;
           }
           JobBean condition = new JobBean(job,job_address,re_sex);
   
           //System.out.println(condition);
   
   
           resp.setCharacterEncoding("UTF-8");
           resp.setHeader("content-type","text/html;charset=UTF-8");
           List<JobBean> index = new Main().queryOne(condition);
           PrintWriter pw = resp.getWriter();
           pw.println("<html><head><title>查询</title></head>" +
                   "<body><a href = \"index.jsp\">返回首页！！</a>" +
                   "<br>" );
   
           for(JobBean i : index){
               pw.println(i);
               pw.println("<br>");
           }
           pw.println("</body></head>");
   
       }
   }

 

1. Delete（删除功能的servlet文件）
   public class delete extends HttpServlet {
   
       @Override
       protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
           String id = req.getParameter("id");
           //System.out.println(id);
           resp.setCharacterEncoding("UTF-8");
           resp.setHeader("content-type","text/html;charset=UTF-8");
   
           new Main().deleteOne(Integer.parseInt(id));
           PrintWriter pw = resp.getWriter();
           pw.println("<html><head><title>删除</title></head>" +
                   "<body><a href = \"index.jsp\">删除成功，返回首页！！</a>" +
                   "</body></head>");
   
       }
   }

 

1. Insert（添加数据的servlet文件）
   public class insert extends HttpServlet {
       @Override
       protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
           String job = new String((req.getParameter("job")).getBytes("ISO-8859-1"),"UTF-8");
   
           String job_address = new String((req.getParameter("job_address")).getBytes("ISO-8859-1"),"UTF-8");
   
           String re_sex = new String((req.getParameter("re_sex")).getBytes("ISO-8859-1"),"UTF-8");
           resp.setCharacterEncoding("UTF-8");
           resp.setHeader("content-type","text/html;charset=UTF-8");
           new Main().insertOne(job,job_address,re_sex);
           PrintWriter pw = resp.getWriter();
           pw.println("<html><head><title>添加</title></head>" +
                   "<body><a href = \"index.jsp\">添加成功，返回首页！！</a>" +
                   "</body></head>");
   
       }
   }

 

1. Updata（修改的servlet文件）
   public class update extends HttpServlet {
       @Override
       protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
           String id = req.getParameter("id");
           String job = new String((req.getParameter("job")).getBytes("ISO-8859-1"),"UTF-8");
   
           String job_address = new String((req.getParameter("job_address")).getBytes("ISO-8859-1"),"UTF-8");
   
           String re_sex = new String((req.getParameter("re_sex")).getBytes("ISO-8859-1"),"UTF-8");
           int mid = Integer.parseInt(id.trim());
           resp.setCharacterEncoding("UTF-8");
           resp.setHeader("content-type","text/html;charset=UTF-8");
   
           new Main().updateOne(mid,job,job_address,re_sex);
           PrintWriter pw = resp.getWriter();
           pw.println("<html><head><title>修改</title></head>" +
                   "<body><a href = \"index.jsp\">修改成功，返回首页！！</a>" +
                   "</body></head>");
   
   
       }
   }

 

1. Index.jsp（入口文件）

<%@ page import="java.util.List" %>
<%@ page import="com.lb.bean.JobBean" %>
<%@ page import="com.lb.Main" %><%-- Created by IntelliJ IDEA. --%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>所有职业信息</title>
  </head>
  <body>
  <h2>职业信息</h2>
  <form action ="/find" method="get">
    查询条件：<br><br>
      <input type="text" name ="job" placeholder="工作名称（可为空）"/>
      <input type ="text" name="job_address" placeholder="工作地址（可为空）"/>
      <select name="re_sex">
          <option>限定性别（可为空）...</option>
          <option value="男">男</option>
          <option value="女">女</option>
          <option value="不限">不限</option>
      </select>
    <input type="submit" value="查询"/>
  </form>

  <br><br>
  <form action ="/insert" method="get">
    工作名称：<input type="text" name ="job"/><br>
    工作地址：<input type="text" name ="job_address"/><br>
    限定性别：<input typpe="text" name="re_sex"/><br><br>
    <input type="submit" value="添加工作信息"/>
  </form>

  <br><br>
  <h3>工作列表所属全部信息：</h3>
  <%
    List<JobBean> jobs = new Main().queryAll();
    for(JobBean job : jobs){
        out.println(job);
        %>
  <a href ="update.jsp?id=<%out.println(job.getId());%>&job=<%out.println(job.getJob());%>
&job_address=<%out.println(job.getJob_address());%>&re_sex=<%out.println(job.getRe_sex());%>">修改</a>
  <a href ="/delete?id=<%out.println(job.getId());%>">删除</a>
  <br>
  <%
    }
  %>

  </body>
</html>

 

12)运行截图

 

2.Spring框架

1. spring简介

1. Java项目的三个层次：

servlet:获取请求参数

service:判断参数的合法性

dao:操作数据库

1. 作用：解决service(业务逻辑层)和其他层的松耦合的问题
2. 特点：是一个分层的JavaEE/JavaSE轻量级的一站式的开源框架

 

1. spring框架jar包的结构

 

docs:文档(api和教程)

lib:框架jar包(jar,文档，源码)

schema:编写配置文件的约束

 

1. spring的核心思想

1. IOC(控制反转)

1. 概念：把对象的创建和管理交给spring
2. 使用IOC实现对象的创建(spring01)

1. 导入spring核心容器jar包(所有的spring项目必须依赖的基础)

 

1. 导入日志框架包(commons-logging-1.2.jar)

C．创建spring的配置文件

 

 

d．被创建对象的类

 

e．运行代码

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

1. 使用IOC实现依赖注入(spring02)

1. 项目结构

 

b.

1. AOP(面向切面编程)(spring09)

1. 在方法运行的过程中，采用横向抽取的方式，动态的注入增强代码
2. AOP编程的相关术语

通知类(Aspect)

通知或增强代码(Advice)

目标类(Target)

连接点(JoinPoint)

切入点(PointCut)

切面(Aspect)

织入(Weave)

 

1. spring对象的创建及初始化(spring03)

1. 通过无参构造

 

1. 通过有参构造

 

1. 通过静态工厂(spring对工厂设计模式的支持)

a.工厂类

 

1. 配置文件

 

1. 通过普通(实例)工厂(spring对工厂设计模式的支持)

1. 工厂类

 

1. 配置文件

 

 

1. spring创建的对象的作用域

1. 控制对象的创建方式
2. 使用：在bean标签中添加scope属性
3. scope属性值：

singleton(单例)：针对同一个bean标签，无论获取多少次都是同一个对象(默认值)

prototype(多例)：针对同一个bean标签，每使用一次创建一个新的对象

request：每有一个请求，创建一个对象

session：每有一个会话，创建一个对象

 

6．Spring创建的对象的装配

1）创建的对象中有一些常见类型的属性，如何给这些属性赋值

2）手动装配(spring04)

（1）有参构造装配

调用有参构造，创建对象的同时给属性赋值

（2）无参构造装配

  先通过无参构造创建对象，之后调用属性的setter方法赋值

3）自动装配(spring自动完成赋值) (spring05)

1. 一般用于依赖注入
2. 实现：在创建A类对象的<bean>标签中添加autowire属性
3. autowire属性的可选值

default/no:不自动注入

byType:根据依赖对象的类型自动注入

byname:根据依赖对象的属性名和spring容器中对象的id是否一致自动注入

constructor：根据构造方法自动注入

 

 

7．Spring注解的使用(spring06)

1）对象创建和注入相关的注解

2）@Component：创建该组件(类)的对象

3）@Component(“组件名”)：创建该组件的对象，同时指定对象的引用名

 

8.spring整合junit完成测试(spring07)

1）在测试spring相关代码时，把spring容器的加载交给测试模块来管理

 

9．Spring整合web项目(spring08)

1）

 

 

3.SpringMVC

1. 是spring的子框架
2. 使用MVC(Model View Controller)设计模式实现web层(jsp,servlet)的开发
3. MVC设计模式，实现分层开发

 

 

 

 

 

 

1. springMVC设计原理

 

 

1. MyBatis spring springMVC整合

1. 整合MyBatis和Spring

1. 把MyBatis相关的对象创建交给spring管理

1. MyBatis的数据库连接池，SqlSessionFactory，SqlSession，Mapper交给spring