学步园

package com.zxh.customer.daogeneric;

import java.io.Serializable;
import java.util.List;
import java.util.Map;

public interface IBaseDao<T extends Serializable> {
 
 /**
  * 获取单条记录
  * @param map
  * @return
  */
 public T selectOne(String sqlId, T entity);
 
 /**
  * 获取记录列表
  * @param map
  * @return
  */
 public List<T> selectList(String sqlId, T entity);
 
 /**
  * 插入一条记录
  * @param map
  */
 public void insert(String sqlId, T entity);
 
 /**
  * 更新记录
  */
 public void update(String sqlId, T entity);
 
 /**
  * 删除记录
  * @param map
  */
 public void delete(String sqlId, T entity);
 
 /**
  * 调用存储过程   还是传参数map吧，无需实体类
  * @param map
  */
 public void callProcedure(String sqlId, Map map);
 
 
}

 

 

 

 

package com.zxh.customer.daogeneric;

import java.io.Serializable;
import java.util.List;
import java.util.Map;

import org.apache.ibatis.session.SqlSession;

import com.zxh.customer.testbasegeneric.util.MybatisUtil;

/**
 * 通用DAO 减少代码量，服务层只需构造map参数 sqlId 为映射sql的id 增删改 要提交事务
 *
 * @author zhangxiaohong
 *
 */
public class BaseDaoImpl<T extends Serializable> implements IBaseDao<T> {

 public T selectOne(String sqlId, T entity) {

  SqlSession session = MybatisUtil.getSessionFactory().openSession();
  T object;

  try {
   object = session.selectOne(sqlId, entity);
  } finally {
   session.close();
  }
  return object;
 }

 public List<T> selectList(String sqlId, T entity) {

  SqlSession session = MybatisUtil.getSessionFactory().openSession();
  List<T> objList;

  try {
   objList = session.selectList(sqlId, entity);
  } finally {
   session.close();
  }
  return objList;
 }

 public void insert(String sqlId, T entity) {

  SqlSession session = MybatisUtil.getSessionFactory().openSession();

  try {
   session.insert(sqlId, entity);
   session.commit();
  } finally {
   session.close();
  }
 }

 public void update(String sqlId, T entity) {

  SqlSession session = MybatisUtil.getSessionFactory().openSession();

  try {
   session.update(sqlId, entity);
   session.commit();
  } finally {
   session.close();
  }
 }

 public void delete(String sqlId, T entity) {

  SqlSession session = MybatisUtil.getSessionFactory().openSession();

  try {
   session.delete(sqlId, entity);
   session.commit();
  } finally {
   session.close();
  }
 }

 public void callProcedure(String sqlId, Map map) {

  SqlSession session = MybatisUtil.getSessionFactory().openSession();

  try {
   session.selectOne(sqlId, map);
  } finally {
   session.close();
  }
 }

}

 

 

 

package com.zxh.customer.daogeneric;

import com.zxh.customer.testbasegeneric.bean.User;

public interface IUserDao extends IBaseDao<User>{

}

 

 

package com.zxh.customer.daogeneric;

import com.zxh.customer.testbasegeneric.bean.User;

public class UserDaoImpl extends BaseDaoImpl<User> implements IUserDao {
 
}

 

 

 

 

 

package com.zxh.customer.testbasegeneric.bean;

public class Parter {

 private Long partyId;
 
 private String partyName;

 public Long getPartyId() {
  return partyId;
 }

 public void setPartyId(Long partyId) {
  this.partyId = partyId;
 }

 public String getPartyName() {
  return partyName;
 }

 public void setPartyName(String partyName) {
  this.partyName = partyName;
 }
  
 
}

 

 

package com.zxh.customer.testbasegeneric.bean;

import java.io.Serializable;

public class User implements Serializable {

 private Long custId;

 private String custName;
 
 public Parter getParter() {
  return parter;
 }

 public void setParter(Parter parter) {
  this.parter = parter;
 }

 private Parter parter;

 public Long getCustId() {
  return custId;
 }

 public void setCustId(Long custId) {
  this.custId = custId;
 }

 public String getCustName() {
  return custName;
 }

 public void setCustName(String custName) {
  this.custName = custName;
 }

}

 

 

 

 

<?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.zxh.parter">
 
 <resultMap type="Parter" id="resultParter">
  <id column="PARTY_ID" property="partyId" />
  <result column="PARTY_NAME" property="partyName" />
 </resultMap>
 
</mapper> 

 

 

<?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.zxh.customer.testbasegeneric">

 <resultMap type="User" id="resultUser">
  <id column="CUST_ID" property="custId" />
  <result column="CUST_NAME" property="custName" />
  <association property="parter" resultMap="com.zxh.parter.resultParter" />
 </resultMap>

 <select id="selectUserById" parameterType="User" resultType="User">
  SELECT CUST_ID as "custId", CUST_NAME "custName" FROM CUST WHERE
  CUST_ID = #{custId}
 </select>

 <select id="selectUsers" parameterType="User" resultMap="resultUser">
  SELECT
  CUST_ID, CUST_NAME FROM CUST WHERE
  CUST_NAME like #{custName}
 </select>

 <!-- 尝试懒加载   注意select语句两个表连接起来别且选择的列包括关联表的内容，否则不会取出关联对象的内容    才能设置lazyLoadingEnabled懒加载和即时加载 -->
 <!-- 多对一情况下   resultMap在设置association属性select 出现懒加载情况  -->
 <!-- 解决n+1问题， 使用sql表连接来解决此问题  -->
 <select id="selectUserLazyLoad" parameterType="User" resultMap="resultUser">
  SELECT CUST_ID, CUST_NAME, P.PARTY_NAME FROM CUST C, PARTY P WHERE
  C.PARTY_ID = P.PARTY_ID AND
  C.CUST_ID = #{custId}
 </select>
 <select id="selectUserLazyLoad11" parameterType="User" resultMap="resultUser">
  SELECT * FROM CUST C, PARTY P WHERE C.PARTY_ID = P.PARTY_ID AND
  C.CUST_ID = #{custId}
 </select>

 

</mapper> 

 

 

 

 

package com.zxh.customer.testbasegeneric.util;

import java.io.Reader;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class MybatisUtil {
 
 private static SqlSessionFactory sqlSessionFactory;
 private static Reader reader;

 static {
  try {
   reader = Resources.getResourceAsReader("config_a/Configuration.xml");
   sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
  } catch (Exception e) {
   e.printStackTrace();
  }
 }
 
 public static SqlSessionFactory getSessionFactory() {
  
  return sqlSessionFactory;
 }

}

 

 

 

 

 

 

 

Configuration.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>

 <!-- 属性配置 xml文件中使用 ${} url "/"路径-文件 或 "."-java类文件 -->
 <properties resource="config_a/jdbc_config.properties">
  <!-- <property name="driver" value="oracle.jdbc.driver.OracleDriver" />
  <property name="url" value="jdbc:oracle:thin:@172.16.1.241:1521:jtcrm" />
  <property name="username" value="jtorder" />
  <property name="password" value="jtorder" /> -->
 </properties>

 <!-- 或者 首先读取properties元素内部的子元素的值, 再读取properties配置文件的值 后者覆盖前者 -->
 <!-- <properties resource="config/jdbc.properties"> <property name="driver"
  value="oracle.jdbc.driver.OracleDriver" /> <property name="url" value="jdbc:oracle:thin:@172.16.1.241:1521:jtcrm"

  /> </properties> -->

 <!-- 设置mybatis3 运行时的行为方式 -->
 <settings>
  <!-- 设置超时时间，它决定驱动等待一个数据库响应的时间 -->
  <setting name="defaultStatementTimeout" value="60000" />
  <!-- 启用或禁用 缓存 -->
  <setting name="cacheEnabled" value="false" />
  <!-- 启用或禁用延迟加载。当禁用时, 所有关联对象都会即时加载 -->
  <setting name="lazyLoadingEnabled" value="true" />
   <!-- 当启用时，有延迟加载属性的对象在被调用时将会完全加载任意属性。否则，每种属性将会按需要加载 --> 
     <setting name="aggressiveLazyLoading" value="true"/>   
  <!-- 允许或不允许多种结果集从一个单独 的语句中返回(需要适合的驱动) 不用考虑 -->
  <setting name="multipleResultSetsEnabled" value="true" />
  <!-- 使用列标签代替列名。 不同的驱动在这 方便表现不同 不用考虑 -->
  <setting name="useColumnLabel" value="true" />
  <!-- 允许 JDBC 支持生成的键。 需要适合的 驱动。 如果设置为 true 则这个设置强制 生成的键被使用 -->
  <setting name="useGeneratedKeys" value="false" />
  <!-- 等等 -->
 </settings>

 <!-- 定义类别名，简化xml文件的配置 -->
 <typeAliases>
  <typeAlias type="com.zxh.customer.testbasegeneric.bean.User" alias="User" />
  <typeAlias type="com.zxh.customer.testbasegeneric.bean.Parter" alias="Parter" />
 </typeAliases>

 <environments default="development">
  <environment id="development">
   <transactionManager type="JDBC" />
   <dataSource type="POOLED">
    <property name="driver" value="${driver}" />
    <property name="url" value="${url}" />
    <property name="username" value="${username}" />
    <property name="password" value="${password}" />
    <!-- <property name="driver" value="oracle.jdbc.driver.OracleDriver" />
    <property name="url" value="jdbc:oracle:thin:@172.16.1.241:1521:jtcrm" />
    <property name="username" value="jtorder" />
    <property name="password" value="jtorder" /> -->
   </dataSource>
  </environment>
 </environments>
 
 <!-- SQL映射文件 -->
 <mappers>
  <mapper resource="com/zxh/customer/testbasegeneric/bean/User.xml" />
  <mapper resource="com/zxh/customer/testbasegeneric/bean/Parter.xml" />
 </mappers>

</configuration>

 

 

jdbc_config.properties

driver=oracle.jdbc.driver.OracleDriver
url=jdbc\:oracle\:thin\:@172.16.1.241\:1521\:jtcrm
username=jtorder
password=jtorder

 

 

 

 

 

package com.zxh.customer.testbasegeneric.test;

import java.util.List;

import com.zxh.customer.daogeneric.IUserDao;
import com.zxh.customer.daogeneric.UserDaoImpl;
import com.zxh.customer.testbasegeneric.bean.User;
 
public class Test {
 

 public static void main(String[] args) {

  // 基本查询
  IUserDao userDao = new UserDaoImpl();
 
  User user = new User();
  user.setCustId(604763L); 
  User resultUser = userDao.selectOne("com.zxh.customer.testbasegeneric.selectUserLazyLoad11", user);
  
  /**
   * 尝试懒加载   注意select语句两个表连接起来别且选择的列包括关联表的内容，否则不会取出关联对象的内容    才能使用懒加载和即时加载
   */
  System.out.println(resultUser.getParter());
  
  System.out.println("成功!");
 }

}