JavaEE体系架构概述、MyBatis总结

JavaEE体系架构概述

java EE是sum公司发布的标准企业级应用规范集合，它提供了一个多层结构的分布式应程序模型，是开发基于网络的企业级应用首选平台。Java EE技术平台的核心思想是“容器”加组件

事务：有明确边界的一组序列，在应用程序中一个请求对应一个事务，当请求发送时，事务开始，当请求结束，事务也就结束。总的来说，事务有四个特性：1、原子性，一个请求要么成功，要么失败，不会再有其他情况；2、一致性，事务处理需要的和得到的时相同的；3、持久性，事务处理的结果时确认的、持久的，如果需要修改就要开启新的事务；4、隔离性，事务与事务之间是互不相扰的

传统web应用缺陷：   

传统的web应用缺乏对分布式组件对象的访问支持，也就是说，它不支持企业分布式应用；并且它对事务的处理控制在数据上，而不是在业务上，同样，它也就没有办法处理业务级事务；而且传统的web应用过于依赖servlet规范，在web应用中所有功能都要有一个servlet，而所有的servlet都运行在web容器中，这样和不利于我们测试代码。

企业级应用：

以服务器为中心，通过网络把服务器和分散的用户联系在一起的应用。一般现代企业级应用具有的特点：1、支持并发；2、事务支持；3、交互支持；4、群集支持；5、安全支持；6、分布式支持；7、web支持

EJB组件：

EJB（Enterprise JavaBean）企业JavaBean，时一个运行在EJB容器当中的服务器端的组件。

JavaEE规范把EJB分为三类：

1. 会话Bean，它封装的是业务逻辑中的动作行为，根据是否保持会话可分为无状态的Bean和有状态的Bean
2. 实体Bean，它表示的是持久层数据的对象视图，通常代表的是业务中的名词
3. 消息驱动Bean，它是JMS（Java消息服务）与EJB集成的结果，可以监听JMS消息服务中的消息

EJB容器：

为EJB组件提供一个运行环境，并对EJB组件提供分布式处理、事务等服务支持。

Java EE 标准结构的缺陷

EJB设计缺陷：EJB业务逻辑组织方式是采用过程式设计，在业务逻辑中，一旦需求改变，业务逻辑就必须实现新的个性，代码会不断增加；而且，实体Bean也被设计成仅仅通过getter和setter方法暴露的持久化数据对象，但是一个真正的对象应该把针对自己状态的行为封装起来。

EJB开发问题：它的开发和测试非常麻烦和冗长。导致这样的原因有三点；第一，编辑、编译、调试周期长；第二，编码冗长、繁琐；第三，必须编写数据传送对象（DTO）

POJO（plain old java object）基于面向对象编程可以作为EJB的替代品，它的持久化可以采用大量的持久化框架，如：MyBatis等，同样，Spring可以对POJO提供事务处理，以及通过依赖注入来配置应用程序

MyBatis

基于持久层封装有两种方式：第一是对JDBC连接进行封装，第二是对sql语句进行封装；只要满足其中之一的为半自动框架，二者都满足的为全自动框架。

mybatis是一种持久层框架，也属于ORM映射。前身是ibatis。mybiatis缺点与缺点：为半自动化，需要自已写SQL语句，需要自己定义映射。增加了程序员的一些操作，但带来了设计上的灵活；对数据库的兼容性比较差差。移植性不好，但可编写灵活和高性能的SQL语句。

mybatis组成

1. 核心对象：SqlSessionFactory SqlSession；SqlSessionFactory 用于生产SqlSession对象的工厂类
2. 配置文件：mybatis.cfg.xml 全局配置文件，配置数据连接信息
3. 多个类配置文件：user.xml相当于接口的实现类，执行SQL语句
4. 支持注解配置

配置文件：mybatis.cfg.xml　　

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "/WEB-INF/dtd/mybatis-3-config.dtd">
<configuration>

    <!-- 开启缓存机制，要求所有的映射器都支持缓存 -->
    <settings>
        <setting name="cacheEnabled" value="true"></setting>
    </settings>


    <typeAliases>
        <!-- 一个一个给实体类型取类的别名 
        <typeAlias type="com.lovo.beans.UserBean" alias="UserBean"/>-->
    
        <package name="com.lovo.beans"/>
    </typeAliases>


    <environments default="first">
        <!-- 一个数据源对应一个环境配置 -->
        <environment id="first">
        
            <!-- 配置事务管理器，type="JDBC"表示使用JDBC事务处理机制来处理事务，MANAGED表示什么都不干，等待外部容器或者其他应用程序来处理事务 -->
            <transactionManager type="JDBC"></transactionManager>
            
            <!-- 配置数据源,type="POOLED"表示使用JDBC连接池；
            UNPOOLED表示不使用JDBC连接池，也就是说每次请求就分别对应一个连接 ；
            JNDI表示需要依赖外部容器提供连接池-->
            
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="lovo"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <!-- 
        <mapper resource="com/lovo/mapper/UserMapper.xml"/> -->
        <package name="com.lovo.mapper"/>
    </mappers>



</configuration>

 类配置文件

<?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.lovo.mapper.UserMapper">
    <!-- 为该映射器配置缓存 -->
    <cache/>
    
    <!-- resultMap 与resultType 是指定的返回结果集与类中属性的关系，而不是返回类型 -->
    <resultMap type="UserBean" id="userMap">
        <id property="id" column="id" javaType="java.lang.Long"/>
        <result property="userName" column="user_name" javaType="java.lang.String"/>
    </resultMap>

    <!-- id="saveUserInfo" 代表着实现的是哪个接口方法，
    parameterType="com.lovo.beans.UserBean" 代表着传入的参数，它的类型
    useGeneratedKeys="true" 代表着获取数据库自增长的ID信息
    keyProperty="u.id" 代表着将获取到的ID值赋值给哪个属性 -->
    <insert id="saveUserInfo" parameterType="UserBean" useGeneratedKeys="true" keyProperty="u.id">
        insert into t_user(id,user_name,sex) values (null,#{u.userName},#{u.sex})
    </insert>
    
    <insert id="batchSaveUser">
        insert into t_user (user_name,sex) values
        
        
        <!-- 动态SQL之foreach的用法 -->
        <!-- collection="users" 用于指定循环集合的名称，如果接口中并未指定参数别名，那么默认就是list
         item="u" 用于指定每次循环后的对象的别名
         separator="," 用于指定每次循环后之间的分割符-->
        <foreach collection="users" item="u" separator=",">
            (#{u.userName},#{u.sex})
        </foreach>
    </insert>

    <update id="updateUserInfo">
        <!-- 
        update t_user set user_name = #{u.userName},sex = #{u.sex} where id = #{id}    
         -->
        <!-- 动态SQL之set if的用法 -->
        update t_user 
        <set>
            <if test="u.userName != null">
                user_name = #{u.userName},
            </if>
        
            <if test="u.sex != null">
                sex = #{u.sex}
            </if>
        
        </set>
        
        <where>
            id = #{id}
        </where>
    </update>

    <delete id="deleteUserById">
        delete from t_user where id = #{id}
    </delete>
    
    <delete id="batchDeleteUser">
        delete from t_user where id in (
        <foreach collection="ids" item="id" separator=",">
            #{id}
        </foreach>
        )    
        
        <!-- 第二种批量删除的写法
        delete from t_user where id in 
        <foreach collection="ids" item="id" separator="," open="(" close=")">
            #{id}
        </foreach> -->
    </delete>

    <select id="getUserInfoById" resultMap="userMap" useCache="true">
        select * from t_user where id = #{id}    
    </select>

    <select id="queryUserInfoByName" resultType="UserBean">
        <!-- CONCAT('%',#{name},'%')该数据库函数，主要用户拼接字符串     -->
        select u.user_name as userName,u.sex as sex from t_user as u where u.user_name like CONCAT('%',#{name},'%')    
    </select>
    
    <select id="findUserInfoByDeptName" resultType="UserBean">
        select u.user_name as userName,u.sex as sex from t_user as u left join t_dept as d on u.fk_dept_id = d.id where d.dept_name like CONCAT('%',#{name},'%')
    </select>
    
    <!-- mybatis取得复合对象内部值的方式是：对象.复合对象.复合对象的属性 -->
    <select id="findUserInfoByDept" resultType="UserBean">
        select u.user_name as userName,u.sex as sex from t_user as u left join t_dept as d on u.fk_dept_id = d.id where d.dept_name like CONCAT('%',#{u.dept.deptName},'%')
    </select>
    
    <!-- 分页统计 -->
    <select id="countUserInfoByParams" resultType="int">
        select count(u.id) from t_user as u left join t_dept as d on u.fk_dept_id = d.id 
        <where>
            <include refid="commonSQL"></include>
        </where>
    </select>
    
    <select id="queryUserInfoByParams" resultType="UserBean">
        select u.id as id,u.user_name as userName,u.sex as sex from t_user as u left join t_dept as d on u.fk_dept_id = d.id 
        <where>
            <include refid="commonSQL"></include>
            limit ${page.index},${page.rows}
        </where>
    </select>
    
    
    <!-- 公共的SQL语句可以提到一处，其他地方采用include获取 -->
    <sql id="commonSQL">
        <if test="userName != null &amp;&amp; userName != ''">
                and u.user_name like CONCAT('%',#{userName},'%')
        </if>
            
        <if test="deptName != null &amp;&amp; deptName != ''">
                and d.dept_name like CONCAT('%',#{deptName},'%')
        </if>
    </sql>
    
    <!-- MAP作为参数传值时，直接通过#{key}去获取对应的值 -->
    
    <select id="countUserInfoByMapParams" parameterType="java.util.Map" resultType="int">
        select count(u.id) from t_user as u left join t_dept as d on u.fk_dept_id = d.id 
        <trim prefix="where" prefixOverrides="and|or">
            <include refid="commonSQL"></include>
        </trim>
    </select>
    
    <select id="queryUserInfoByMapParams" resultType="UserBean">
    select u.id as id,u.user_name as userName,u.sex as sex from t_user as u left join t_dept as d on u.fk_dept_id = d.id 
        <trim prefix="where" prefixOverrides="and|or" suffix="order by" suffixOverrides="and|or">
            <include refid="commonSQL"></include>
        </trim>
        <!--SQL语法： order by需要放置在limit之前 -->
        u.id desc limit ${index},${rows}
    </select>
    
    <select id="queryUserInfoByNameAndSex" resultType="UserBean">
        select id as id,user_name as userName,sex as sex from t_user
        <where>
        
        <!-- choose when 等同于java中的switch case的组合，
        只匹配一项，如果都不匹配，就执行otherwise中的内容，等同于default-->
            <choose>
                <when test="name != null">
                    user_name like CONCAT('%',#{name},'%')
                </when>
                <when test="sex != null">
                    and sex like CONCAT('%',#{sex},'%')
                </when>
                <otherwise>1=1</otherwise>
            </choose>
        </where>
    </select>
    
</mapper>

注解配置

package com.lovo.mapper;

import java.util.List;
import java.util.Map;

import org.apache.ibatis.annotations.CacheNamespace;
import org.apache.ibatis.annotations.CacheNamespaceRef;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Options;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.ResultMap;
import org.apache.ibatis.annotations.ResultType;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;

import com.lovo.beans.Page;
import com.lovo.beans.UserBean;


@CacheNamespace//为该Mapper映射文件开启一个二级缓存空间
@CacheNamespaceRef(value = UserMapper.class)
public interface UserMapper {

    /**
     * 保存用户
     * 
     * @param user
     * @return
     */
    @Insert(value = "insert into t_user(id,user_name,sex) values (null,#{u.userName},#{u.sex})")
    @Options(useGeneratedKeys = true, keyProperty = "u.id")
    public int saveUserInfo(@Param("u") UserBean user);

    /**
     * 根据ID修改用户
     * 
     * @param user
     * @param id
     * @return
     */
    
    public int updateUserInfo(@Param("u") UserBean user, @Param("id") Long id);

    /**
     * 根据ID删除用户
     * 
     * @param id
     * @return
     */
    @Delete(value = "delete from t_user where id = #{id}")
    public int deleteUserById(@Param("id") Long id);

    /**
     * 根据ID查询用户
     * 
     * @param id
     * @return
     */
    @Select(value = "select * from t_user where id = #{id}")
    @Options(useCache = true)
    @ResultMap(value = "userMap")
    public UserBean getUserInfoById(@Param("id") Long id);

    /**
     * 根据用户名模糊查询所有的用户
     * 
     * @param name
     * @return
     */
    @Select("select u.user_name as userName,u.sex as sex from t_user as u where u.user_name like CONCAT('%',#{name},'%')")
    @ResultType(UserBean.class)
    public List<UserBean> queryUserInfoByName(@Param("name") String name);

    /**
     * 批量的增加
     * 
     * @param users
     * @return
     */
    public int batchSaveUser(@Param("users") List<UserBean> users);

    /**
     * 批量的删除
     * 
     * @param ids
     * @return
     */
    public int batchDeleteUser(@Param("ids") Long[] ids);

    /**
     * 根据部门名称查询所有的用户
     * 
     * @param deptName
     * @return
     */
    @Select("select u.user_name as userName,u.sex as sex from t_user as u left join t_dept as d on u.fk_dept_id = d.id where d.dept_name like CONCAT('%',#{name},'%')")
    @Results({
            @Result(id = true, property = "id", column = "id", javaType = Long.class),
            @Result(property = "userName", column = "userName", javaType = String.class),
            @Result(property = "sex", column = "sex", javaType = String.class)
            })
    public List<UserBean> findUserInfoByDeptName(@Param("name") String deptName);

    /**
     * 根据用户中的部分信息查询用户
     * 
     * @param user
     * @return
     */
    @Select("select u.user_name as userName,u.sex as sex from t_user as u left join t_dept as d on u.fk_dept_id = d.id where d.dept_name like CONCAT('%',#{u.dept.deptName},'%')")
    @ResultType(UserBean.class)
    public List<UserBean> findUserInfoByDept(@Param("u") UserBean user);

    /**
     * 根据条件统计查询总条数
     * 
     * @param userName
     * @param deptName
     * @return
     */
    public int countUserInfoByParams(@Param("userName") String userName,
            @Param("deptName") String deptName);

    /**
     * 查询满足条件的分页数据
     * 
     * @param userName
     * @param deptName
     * @param page
     * @return
     */
    public List<UserBean> queryUserInfoByParams(
            @Param("userName") String userName,
            @Param("deptName") String deptName, @Param("page") Page page);

    /**
     * 根据条件统计查询总条数
     * 
     * @param map
     * @return
     */
    public int countUserInfoByMapParams(Map<String, Object> map);

    /**
     * 查询满足条件的分页数据
     * 
     * @param map
     * @return
     */
    // Map作为多参数传值时，不能与其他类型参数结合。
    public List<UserBean> queryUserInfoByMapParams(Map<String, Object> map);

    /**
     * 根据用户名与密码查询用户
     * 
     * @param name
     * @param sex
     * @return
     */
    public List<UserBean> queryUserInfoByNameAndSex(@Param("name") String name,
            @Param("sex") String sex);

}