spring+springMVC+mybatis基础代码

阅读更多

web.xml配置

 

   
   
     
         
       log4jConfigLocation      
       classpath:log4j.properties      
     
     
         
       log4jRefreshInterval      
       1800000      
      
     
   
       org.springframework.web.util.Log4jConfigListener      
   
   
   
   
   
	
	    contextConfigLocation
	    classpath:spring-main.xml
	  
   
    
	
		可以自定义servlet.xml配置文件的位置和名称，默认为WEB-INF目录下，
		名称为如spring-servlet.xml
	    spring mvc
	    org.springframework.web.servlet.DispatcherServlet
	    
	    	contextConfigLocation
	        classpath:spring-mvc.xml
	    
	     1
	
	
	
	    spring mvc
	    *.do
	
	
	
	
	   
	     org.springframework.web.context.ContextLoaderListener
	   
	
	
   
	
    
        /index.html
        /index.jsp
    

 spring-main.xml spring综合配置文件

 

 

	定义业务层和集成层对象，包括Action、Service、BO、DAO、SAO、EJB、JNDI资源
	
	
	
	
	
		
			可以引用CLASSPATH中common-spring.properties中定义的变量
			
			classpath:common-spring.properties
		
		
	

	
	
	

	
	
    

 

 

 

spring-mvc.xml 配置

 

	此配置对应spring mvc相关拦截配置
	
	
    
 
    
    
 
    
    
     
    
    
        
        
        
        
    
    
    
	
	    
	        
	        
	            
	
    

 

 

spring-orm.xml  数据源相关，数据访问相关，事务配置

 

	此配置文件主要针对数据库连接，事务，session控制等等
	
	
	
	
	
    
	
		
		
		
		
		
		
		
		 
		
		
		  
		
		 
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
	
	
	
	
	  
	      
	      
	  
	
	   
          
      
	
	  
      
        
          
     
    
      
	  
	      
	  
	  
	  
    

 

 

 

common-spring.properties 综合配置文件

 

#C3P0 连接池配置
jdbc.driverClass=oracle.jdbc.driver.OracleDriver
jdbc.jdbcUrl=jdbc:oracle:thin:@10.20.128.115:1526:d0rsapp
jdbc.user=elisdata
jdbc.password=ilovetong
#连接池中保留的最小连接数。 
jdbc.miniPoolSize= 20
#连接池中保留的最大连接数。 
jdbc.maxPoolSize= 50
#初始化时获取N个连接，取值应在minPoolSize与maxPoolSize之间。Default: 3  
jdbc.initialPoolSize= 20
#最大空闲时间,设置值内未使用则连接被丢弃。若为0则永不丢弃。    
jdbc.maxIdleTime= 25000
#当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。  
jdbc.acquireIncrement= 3

#定义在从数据库获取新连接失败后重复尝试的次数。Default: 30  
jdbc.acquireRetryAttempts= 30
#两次连接中间隔时间，单位毫秒。Default: 1000 
jdbc.acquireRetryDelay= 1000
#如果设为true那么在取得连接的同时将校验连接的有效性。Default: false  
jdbc.testConnectionOnCheckin= true
#c3p0将建一张名为Test的空表，并使用其自带的查询语句进行测试。如果定义了这个参数那么属性preferredTestQuery将被忽略。你不能在这张Test表上进行任何操作，它将只供c3p0测试使用。
jdbc.automaticTestTable= c3p0TestTable
#当连接池用完时客户端调用getConnection()后等待获取新连接的时间，超时后将抛出 SQLException,如设为0则无限期等待。单位毫秒。Default: 0  
jdbc.idleConnectionTestPeriod= 18000
#定义所有连接测试都执行的测试语句。在使用连接测试的情况下这个一显著提高测试速度。
#注意：测试的表必须在初始数据源的时候就存在。Default: null，该配置项不可以和automaticTestTable同时使用
jdbc.preferredTestQuery=select id from test_c3p0 where id=1
#超时时间
jdbc.checkoutTimeout=3000

 

 

 

log4j.properties 日志配置相关

 

#ibatis log4j运行级别调到DEBUG可以在控制台打印出ibatis运行的sql语句,方便调试:
### 设置Logger输出级别和输出目的地 ###
log4j.rootLogger=info,stdout,logfile
### 把日志信息输出到控制台 ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
#log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.SimpleLayout

### 把日志信息输出到文件：default ###
log4j.appender.logfile=org.apache.log4j.FileAppender
log4j.appender.logfile.File=${catalina.home}/logs/default.log
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %F %p %m%n

###显示SQL语句部分
log4j.logger.com.mybatis=DEBUG
log4j.logger.com.mybatis.common.jdbc.SimpleDataSource=DEBUG
log4j.logger.com.mybatis.common.jdbc.ScriptRunner=DEBUG
log4j.logger.com.mybatis.sqlmap.engine.impl.SqlMapClientDelegate=DEBUG
log4j.logger.java.sql.Connection=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

#job
log4j.logger.com.jinguanjia.task.service.impl=INFO,task
log4j.appender.task=org.apache.log4j.DailyRollingFileAppender
log4j.appender.task.File=${catalina.home}/logs/task.log
log4j.appender.task.Append=true
log4j.appender.task.layout=org.apache.log4j.PatternLayout 
log4j.appender.task.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss}|%t|%-5p|%c,%L,%M|->%m%n

 

 

mybatis-config.xml mybatis综合配置文件

 

 

 

基础Dao

 

package com.fast.base.dao;

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

/**
 * mybatis基础Dao
 * @author LUSHUIFA242
 *
 */
public interface BaseDao{

	/**
     * 对对象进行持久化操作，如果成功则返回1
     * 失败返回-1
     * @param obj
     * @return
     */
	 int save(T bean);
	
	/**
	 * 批量保存
	 * @param objList
	 * @return 成功返回操作的成功的数量 失败则回滚并返回-1
	 */
	 int save(List beanList);
	
	/**
     * 对对象进行持久化操作，如果成功则返回1
     * 失败返回-1
     * @param obj
     * @return
     */
	 int saveOrUpdate(T bean);
	
	/**
	 * 批量保存与更新 
	 * @param objList
	 * @return 成功返回操作的成功的数量 失败则回滚并返回-1
	 */
	 int saveOrUpdate(List beanList);
	
	 /**
     * 修改指定的持久化对象
     * @param id
     * @param obj
     */
     int update(T bean);
    
    /**
     * 修改指定的持久化对象,批量
     * @param objList
     * @return
     */
     int update(List beanList);
    
    /**
     * 删除指定id的持久化对象
     * @param id
     * @return 
     */
     int delete(Object primaryKey);
   
    
    /**
     * 返回持久化对象
     * @param obj
     * @return 找到则返回，否则返回空
     */
     T queryObject(T bean);
    
    /**
     * 返回持久化对象
     * @param primaryKey
     * @return 找到则返回，否则返回空
     */
     T queryObjectByPrimaryKey(Object primaryKey);
    
    /**
     * 返回持久化对象
     * @param queryParam
     * @return 找到则返回，否则返回空
     */
     T queryObjectByParam(Map queryParam);
    
    /**
     * 返回列表 
     * @param queryParam
     * @return 找到则返回，否则返回空
     */
     List queryList(T bean);
    
    /**
     * 返回列表 
     * @param bean
     * @param limitSize
     * @return 找到则返回，否则返回空
     */
     List queryList(T bean,int limitSize);
    
    /**
     * 返回列表 
     * @param bean
     * @param startIndex
     * @param endIndex
     * @return 找到则返回，否则返回空
     */
     List queryList(T bean,int startIndex,int endIndex);
    
    /**
     * 返回列表 
     * @param queryParam
     * @return 找到则返回，否则返回空
     */
     List queryListByParam(Map queryParam);
    
    /**
     * 返回列表 
     * @param queryParam
     * @param limitSize
     * @return 找到则返回，否则返回空
     */
     List queryListByParam(Map queryParam,int limitSize);
    
    /**
     * 返回列表 
     * @param queryParam
     * @param startIndex
     * @param endIndex
     * @return 找到则返回，否则返回空
     */
     List queryListByParam(Map queryParam,int startIndex,int endIndex);
    
    /**
     * 统计所有记录数
     * @return
     */
     long count();
    
    /**
     * 根据条件统计
     * @param bean
     * @return
     */
     long count(T bean);
    
	void setXmlName(String xmlName);
    
}

 

 

基础dao实现类

 

package com.fast.base.dao.impl;

import java.sql.Connection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;

import org.apache.ibatis.session.SqlSession;
import org.springframework.stereotype.Component;

import com.alibaba.fastjson.JSONObject;
import com.fast.base.dao.BaseDao;

@Component
public class BaseDaoImpl implements BaseDao {

	@Resource(name = "sqlSession")
	private SqlSession session;
	private String path = "com.fast.app.mapper.";
	
	private String xmlName;
	
	protected BaseDaoImpl(){
		path = path + this.getXmlName();
	}
	
	protected BaseDaoImpl(String xmlName) {
		this.setXmlName(xmlName);
		path = path + xmlName;
	}
	
	protected String getMethodPath(String methodName) {
		return path +"."+ methodName;
	}
	
	/**
     * 对对象进行持久化操作，如果成功则返回1
     * 失败返回-1
     * @param obj
     * @return
     */
	public  int save(T bean){
		return this.session.insert(getMethodPath("save"), bean);
	}
	
	/**
	 * 批量保存
	 * @param objList
	 * @return 成功返回操作的成功的数量 失败则回滚并返回-1
	 */
	public  int save(List beanList) {
		return this.session.insert(getMethodPath("batchSave"), beanList);
	}
	
	/**
     * 对对象进行持久化操作，如果成功则返回1
     * 失败返回-1
     * @param obj
     * @return
     */
	public  int saveOrUpdate(T bean) {
		return this.session.insert(getMethodPath("saveOrUpdate"), bean);
	}
	
	/**
	 * 批量保存与更新 
	 * @param objList
	 * @return 成功返回操作的成功的数量 失败则回滚并返回-1
	 */
	public  int saveOrUpdate(List beanList) {
		int actionCount = -1;
		for (T t : beanList) {
			if(saveOrUpdate(t)>0){
				actionCount++;
			}
		}
		return actionCount;
	}
	
	 /**
     * 修改指定的持久化对象
     * @param id
     * @param obj
     */
    public  int update(T bean) {
		return this.session.update(getMethodPath("update"), bean);
	}
    
    /**
     * 修改指定的持久化对象,批量
     * @param objList
     * @return
     */
    public  int update(List beanList) {
    	return this.session.update(getMethodPath("batchUpdate"), beanList);
	}
    
    /**
     * 删除指定id的持久化对象
     * @param id
     */
    public  int delete(Object primaryKey) {
		return this.session.delete(getMethodPath("deleteByPrimaryKey"), primaryKey);
    	
	}
   
    /**
     * 返回持久化对象
     * @param obj
     * @return 找到则返回，否则返回空
     */
    public  T queryObject(T bean) {
		return this.session.selectOne(getMethodPath("queryObject"), bean);
	}
    
    /**
     * 返回持久化对象
     * @param primaryKey
     * @return 找到则返回，否则返回空
     */
    public  T queryObjectByPrimaryKey(Object primaryKey) {
    	return this.session.selectOne(getMethodPath("queryObjectByPrimaryKey"), primaryKey);
	}
    
    /**
     * 返回持久化对象
     * @param queryParam
     * @return 找到则返回，否则返回空
     */
    public  T queryObjectByParam(Map queryParam) {
    	return this.session.selectOne(getMethodPath("queryObjectByParam"), queryParam);
	}
    
    /**
     * 返回列表 
     * @param queryParam
     * @return 找到则返回，否则返回空
     */
    public  List queryList(T bean) {
    	return queryList(bean,-1);
	}
    
    /**
     * 返回列表 
     * @param bean
     * @param limitSize -1
     * @return 找到则返回，否则返回空
     */
    public  List queryList(T bean,int limitSize) {
    	try {
    		Map param = new HashMap();
    		param.putAll((Map) JSONObject.toJSON(bean));
        	param.put("limitSize", limitSize);
        	return this.session.selectList(getMethodPath("queryList"), param);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}
    
    /**
     * 返回列表 此方法适用分页
     * @param bean
     * @param startIndex
     * @param endIndex
     * @return 找到则返回，否则返回空
     */
    public  List queryList(T bean,int startIndex,int endIndex){
    	Map param = new HashMap();
    	param.putAll((Map) JSONObject.toJSON(bean));
    	param.put("startIndex", startIndex);
    	param.put("endIndex", endIndex);
    	return this.session.selectList(getMethodPath("queryListInRange"), param);
    }
    
    /**
     * 返回列表 
     * @param queryParam
     * @return 找到则返回，否则返回空
     */
    public  List queryListByParam(Map queryParam){
    	return this.session.selectList(getMethodPath("queryListByParam"), queryParam);
    }
    
    /**
     * 返回列表 
     * @param queryParam
     * @param limitSize
     * @return 找到则返回，否则返回空
     */
    public  List queryListByParam(Map queryParam,int limitSize){
    	queryParam.put("limitSize", limitSize);
    	return this.session.selectList(getMethodPath("queryListByParam"), queryParam);
    }
    
    /**
     * 返回列表 
     * @param queryParam
     * @param startIndex
     * @param endIndex
     * @return 找到则返回，否则返回空
     */
    public  List queryListByParam(Map queryParam,int startIndex,int endIndex){
    	queryParam.put("startIndex", startIndex);
    	queryParam.put("endIndex", endIndex);
    	return this.session.selectList(getMethodPath("queryListByParam"), queryParam);
    }
    
    /**
     * 统计所有记录数
     * @return
     */
    public  long count(){
    	return this.session.selectOne(getMethodPath("count"));
    }
    
    /**
     * 根据条件统计
     * @param bean
     * @return
     */
    public  long count(T bean){
    	return this.session.selectOne(getMethodPath("count"),bean);
    }

	/**
	 * 得到数据库连接
	 * @return
	 */
	public Connection getConn(){
		return this.getSession().getConnection();
	}

	/**
	 * 得到mybatis session操作类
	 * @return
	 */
	public SqlSession getSession() {
		return session;
	}

	public void setSession(SqlSession session) {
		this.session = session;
	}

	public String getXmlName() {
		return xmlName;
	}

	@Override
	public void setXmlName(String xmlName) {
		this.xmlName = xmlName;
	}
}