spring整合通用Mapper+ PageHelper + log4j2 + maven

迷南。 2024-02-18 15:57 10阅读 0赞

最近公司项目用到了通用Mapper组件，使用后发现它比Mybatis官方提供的逆向工程还要好用一点，于是决定将它的使用记录下来，做一个小demo

闲话不多说，直接上代码

## 第一步：在开发工具上新建一个maven工程，在pom.xml引入如下依赖 ##

<properties>
    		<junit.version>4.12</junit.version>
    		<spring.version>4.2.5.RELEASE</spring.version>
    		<mybatis.version>3.3.0</mybatis.version>
    		<mybatis.spring.version>1.2.2</mybatis.spring.version>
    		<mapper.version>3.3.9</mapper.version>
    		<pagehelper.version>4.1.6</pagehelper.version>
    		<mysql.version>5.1.32</mysql.version>
    		<slf4j.version>1.6.4</slf4j.version>
    		<jackson.version>2.5.0</jackson.version>
    		<druid.version>1.0.9</druid.version>
    		<jstl.version>1.2</jstl.version>
    		<servlet-api.version>2.5</servlet-api.version>
    		<jsp-api.version>2.0</jsp-api.version>
    		<joda-time.version>2.5</joda-time.version>
    		<commons-lang3.version>3.3.2</commons-lang3.version>
    		<commons-io.version>1.3.2</commons-io.version>
    		<commons-net.version>3.3</commons-net.version>
    		<jsqlparser.version>0.9.1</jsqlparser.version>
    		<commons-fileupload.version>1.3.1</commons-fileupload.version>
    	</properties>

<dependencies>
    		
    		<dependency>
    			<groupId>org.apache.commons</groupId>
    			<artifactId>commons-lang3</artifactId>
    			<version>${commons-lang3.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.apache.commons</groupId>
    			<artifactId>commons-io</artifactId>
    			<version>${commons-io.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>commons-net</groupId>
    			<artifactId>commons-net</artifactId>
    			<version>${commons-net.version}</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>com.fasterxml.jackson.core</groupId>
    			<artifactId>jackson-databind</artifactId>
    			<version>${jackson.version}</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>junit</groupId>
    			<artifactId>junit</artifactId>
    			<version>${junit.version}</version>
    			<scope>test</scope>
    		</dependency>
    		
    		<dependency>
    			<groupId>org.mybatis</groupId>
    			<artifactId>mybatis</artifactId>
    			<version>${mybatis.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.mybatis</groupId>
    			<artifactId>mybatis-spring</artifactId>
    			<version>${mybatis.spring.version}</version>
    		</dependency>
    		
            <dependency>
                <groupId>tk.mybatis</groupId>
                <artifactId>mapper</artifactId>
                <version>${mapper.version}</version>
            </dependency>
    		
    		<dependency>
    			<groupId>com.github.pagehelper</groupId>
    			<artifactId>pagehelper</artifactId>
    			<version>${pagehelper.version}</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>mysql</groupId>
    			<artifactId>mysql-connector-java</artifactId>
    			<version>${mysql.version}</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>com.alibaba</groupId>
    			<artifactId>druid</artifactId>
    			<version>${druid.version}</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-context</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-beans</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-webmvc</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-jdbc</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-aspects</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-jms</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-context-support</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>jstl</groupId>
    			<artifactId>jstl</artifactId>
    			<version>${jstl.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>javax.servlet</groupId>
    			<artifactId>servlet-api</artifactId>
    			<version>${servlet-api.version}</version>
    			<scope>provided</scope>
    		</dependency>
    		<dependency>
    			<groupId>javax.servlet</groupId>
    			<artifactId>jsp-api</artifactId>
    			<version>${jsp-api.version}</version>
    			<scope>provided</scope>
    		</dependency>
    		
    		<dependency>  
                <groupId>org.springframework</groupId>  
                <artifactId>spring-test</artifactId>  
                <version>${spring.version}</version>  
                <scope>provided</scope>  
    		</dependency>
    		
    		<dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j-api</artifactId>
                <version>2.7</version>
            </dependency>
            <dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j-core</artifactId>
                <version>2.7</version>
            </dependency>
    		<dependency>
                 <groupId>org.apache.logging.log4j</groupId>
                 <artifactId>log4j-web</artifactId>
                 <version>2.7</version>
            </dependency>
    	</dependencies>

<build>
      		<plugins>
    			
    			<plugin>
    				<groupId>org.apache.maven.plugins</groupId>
    				<artifactId>maven-compiler-plugin</artifactId>
    				<version>3.2</version>
    				<configuration>
    					<source>1.7</source>
    					<target>1.7</target>
    					<encoding>UTF-8</encoding>
    				</configuration>
    			</plugin>
    			
    			<plugin>
    				<groupId>org.apache.tomcat.maven</groupId>
    				<artifactId>tomcat7-maven-plugin</artifactId>
    				<configuration>
    					<port>8080</port>
    					<path>/</path>
    				</configuration>
    			</plugin>
    		</plugins>
      	</build>

###### 注意：这里的maven工程是一个war包，配置tomcat插件后，在eclipse中使用tomcat7:run即可运行本项目 ######

## 第二步：在classpath下创建log4j2.xml ##

<?xml version="1.0" encoding="UTF-8"?>  
      <Configuration status="OFF" monitorInterval="1800">
        
          <properties>  
              <property name="LOG_HOME">D:/log4j2/mybatis/genertor/logs/</property>
              <property name="ERROR_LOG_FILE_NAME">error</property>
          </properties>  
        
        
          <Appenders>  
          	
              <Console name="Console" target="SYSTEM_OUT">  
                  <PatternLayout pattern="%d %-5p (%F:%L) - %m%n" />  
              </Console>  
        	
              <RollingRandomAccessFile name="ErrorLog"  
                                       fileName="${LOG_HOME}/${ERROR_LOG_FILE_NAME}.log"  
                                       filePattern="${LOG_HOME}/${ERROR_LOG_FILE_NAME}.log.%d{yyyy-MM-dd}.gz">  
                  <PatternLayout  
                          pattern="%d %-5p (%F:%L) - %m%n"/>  
                  <Policies>  
                  	  
                      <TimeBasedTriggeringPolicy/>  
                      
                      <SizeBasedTriggeringPolicy size="100 MB"/>  
                  </Policies>
                    
                  <DefaultRolloverStrategy max="20"/>  
              </RollingRandomAccessFile>  
              <param name="Encoding" value="UTF-8" />
          </Appenders>  
        
          <Loggers>  
                
              <logger name="org.springframework.core" level="info">  
              </logger>  
              <logger name="org.springframework.beans" level="info">  
              </logger>  
              <logger name="org.springframework.context" level="info">  
              </logger>  
              <logger name="org.springframework.web" level="info">  
              </logger>  
              <logger name="org.springframework.test.context.junit4.SpringJUnit4ClassRunner" level="info">  
              </logger>  
              <logger name="com.lmsq.shaxuntech" level="debug" includeLocation="true" additivity="false">
                  <appender-ref ref="ErrorLog"/>  
                  <appender-ref ref="Console"/>  
              </logger>  
        
              <root level="info" includeLocation="true">
                  <appender-ref ref="ErrorLog"/>
                  <appender-ref ref="Console"/>  
              </root>  
          </Loggers>  
          
      </Configuration>

注意：log4j2.xml文件的详细配置大家可以参考博客: [log4j2详解][log4j2]

## 第三步：配置applicationContext-dao.xml文件 ##

<context:property-placeholder location="classpath:conf/*.properties" file-encoding="utf-8" />
    	
    	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
    		destroy-method="close">
    		<property name="url" value="${jdbc.url}" />
    		<property name="username" value="${jdbc.username}" />
    		<property name="password" value="${jdbc.password}" />
    		<property name="driverClassName" value="${jdbc.driver}" />
    		<property name="maxActive" value="16" />
    		<property name="minIdle" value="6" />
    		
    	</bean>
    	
    	
    	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    		
    		<property name="dataSource" ref="dataSource" />
    		
    		<property name="configLocation" value="classpath:mybatis/SqlMapConfig.xml" />
    		
    		<property name="mapperLocations" value="classpath:mybatis/mapper/*.xml"/>
    	</bean>
    	
    	<bean class="tk.mybatis.spring.mapper.MapperScannerConfigurer">
    		<property name="basePackage" value="com.lmsq.shaxuntech.dao" />
    	</bean>

注意：

1：这里的Mapper接口扫描使用的类是：tk.mybatis.spring.mapper.MapperScannerConfigurer，而原生的mybatis是org.mybatis.spring....包下的MapperScannerConfigurer类，注意区分  
2：<context:property-placeholder />元素中的 file-encoding="utf-8" 属性是为了解决配置文件中的中文乱码问题，没中文的情况下，该属性可配可不配

3：本项目未分享数据库的properties文件，你们需要手动创建properties文件用于存储数据库链接四大参数

## 第四步：配置applicationContext-service.xml ##

<context:component-scan base-package="com.lmsq.shaxuntech.service"/>

注意：由于项目仅供测试，所有并没有给项目加上事务的相关配置

## 第五步：配置springMVC的配置文件：springmvc.xml ##

<context:property-placeholder location="classpath:conf/*.properties"  file-encoding="utf-8" />
    	
    	<context:component-scan base-package="com.lmsq.shaxuntech.api" use-default-filters="false">
    	    <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller" />
    	    
    	    <context:include-filter type="annotation" expression="org.springframework.web.bind.annotation.ControllerAdvice" />
    	</context:component-scan>
    	
    	
    				 
    	<mvc:annotation-driven>  
            <mvc:message-converters>    
                <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">    
                    <property name="objectMapper">    
                        <bean class="com.fasterxml.jackson.databind.ObjectMapper">  
                                
                            <property name="dateFormat">    
                                <bean class="java.text.SimpleDateFormat">    
                                    <constructor-arg type="java.lang.String" value="yyyy-MM-dd HH:mm:ss" />    
                                </bean>    
                            </property>   
                        </bean>    
                    </property>    
                </bean>    
            </mvc:message-converters>    
        </mvc:annotation-driven> 
    
    
    	
    	<mvc:resources location="/js/" mapping="/js/**"/>
    	<mvc:resources location="/json/" mapping="/json/**"/> 
    	
    	<mvc:cors>
    		<mvc:mapping path="/**" allowed-origins="*" allow-credentials="true" max-age="1800" allowed-methods="GET,POST,PUT,DELETE,PATCH,OPTIONS"/>
    	</mvc:cors>

注意：这里的context:component-scan配置方式是springMVC提供的异常处理机制要求的配置方式，如果项目仅供测试，没必要在项目中抛出、捕获异常信息，可以直接配置成 :

<context:component-scan base-package="你的Controller所在路径"/>

## 第六步：配置SqlMapConfig.xml文件 ##

注意:新手无需修改本配置，直接复制就可以了

## 第七步 : 给新手提供一套通用Mapper的逆向工程生成工具 : [通用Mapper-generator][Mapper-generator] ##

生成好代码后，将代码复制到自己的工程里即可，工具里面有逆向工程全程配置使用说明，非常方便！

注意：

1：逆向工具生成的Mapper接口必须复制到MapperScannerConfigurer类能扫描到的位置

2：建议将生成的Mapper.xml文件复制到项目的classpath下的目录中，我这里是放在classpath:mybatis/mapper下

## 第八步：创建service层及其实现类 ##

public interface UserService {
    	
    	/**
    	 * 方法一：查询会员信息
    	 * 
    	 * @param userId
    	 * @param token
    	 * @return
    	 */
    	public ResponseContent getUserInfo(String userId);
    }

@Service
    public class UserServiceImpl implements UserService{
    	@Autowired
    	private SysUserMapper userMapper;
    	
    	@Override
    	public ResponseContent getUserInfo(String userId) {
    		SysUser record = new SysUser();
    		record.setUserId(userId);
    		SysUser user = userMapper.selectOne(record);
    		if (user == null) {
    			return null;
    		}
    		return ResponseUtil.okContent(user, null);
    	}
    
    }

注意：1：这里的SysUserMapper是我用逆向工程工具生成的Mapper接口，而selectOne()方法是通用Mapper给我们提供的一个方法，用于返回一条数据,这里用生成的PO类SysUser接收返回的结果集

2：这里的ResponseContent是接口返回数据封装类，如无特殊要求，可以将它改为PO类（SysUser）即可

## 第九步:定义全局异常处理类【无异常处理需求的情况下可以忽略此类】 ##

/** 加上@ControllerAdvice注解即可将本类作为异常处理类 */
    @ControllerAdvice
    public class GlobalExceptionHandler extends RestExceptionHandler{
    
        //空指针异常
        @ExceptionHandler(NullPointerException.class)  
        @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)/**500*/
        @ResponseBody  
        public ResponseContent nullPointerExceptionHandler(HttpServletRequest req,NullPointerException ex) {  
        	 String errMsg = "NullPointer Exception";
             ex.printStackTrace();
             return ResponseUtil.errorContent(req, ErrorCode.NULLPOINT, errMsg, ex.getMessage());
        }   
        
        
        
        //类型转换异常
        @ExceptionHandler(ClassCastException.class)  
        @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)/**500*/
        @ResponseBody  
        public ResponseContent classCastExceptionHandler(HttpServletRequest req,ClassCastException ex) {  
        	String errMsg = "classCast exception";
            ex.printStackTrace();
            return ResponseUtil.errorContent(req, ErrorCode.CLASS_CAST, errMsg, ex.getMessage());
        }  
    
        //IO异常
        @ExceptionHandler(IOException.class)
        @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)/**500*/
        @ResponseBody  
        public ResponseContent iOExceptionHandler(HttpServletRequest req,IOException ex) {  
        	String errMsg = "IO exception";
            ex.printStackTrace();
            return ResponseUtil.errorContent(req, ErrorCode.SYS_EXCEPTION, errMsg, ex.getMessage());
        }  
        //未知方法异常
        @ExceptionHandler(NoSuchMethodException.class)  
        @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)/**500*/
        @ResponseBody  
        public ResponseContent noSuchMethodExceptionHandler(HttpServletRequest req,NoSuchMethodException ex) {  
        	String errMsg = "noSuchMethod exception";
            ex.printStackTrace();
            return ResponseUtil.errorContent(req, ErrorCode.UNDEFINED, errMsg, ex.getMessage());
        }  
    
        //数组越界异常
        @ExceptionHandler(IndexOutOfBoundsException.class) 
        @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)/**500*/
        @ResponseBody  
        public ResponseContent indexOutOfBoundsExceptionHandler(HttpServletRequest req,IndexOutOfBoundsException ex) {  
        	String errMsg = "indexOutOfBounds exception";
            ex.printStackTrace();
            return ResponseUtil.errorContent(req, ErrorCode.SYS_EXCEPTION, errMsg, ex.getMessage());
        }
        
       
        // 数据格式异常 
        @ExceptionHandler(NumberFormatException.class) 
        @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)/**500*/
        @ResponseBody  
        public ResponseContent numberFormatExceptionExceptionHandler(HttpServletRequest req,NumberFormatException ex) {  
        	String errMsg = "numberFormat Exception";
            ex.printStackTrace();
            return ResponseUtil.errorContent(req, ErrorCode.SYS_EXCEPTION, errMsg, ex.getMessage());
        }
    
        // 参数缺失异常
        @ExceptionHandler(MissingServletRequestParameterException.class) 
        @ResponseStatus(HttpStatus.EXPECTATION_FAILED)/**500*/
        @ResponseBody  
        public ResponseContent missingServletRequestParameterException(HttpServletRequest req, MissingServletRequestParameterException ex) {  
        	String errMsg = "lack params Exception";
            ex.printStackTrace();
            return ResponseUtil.errorContent(req, ErrorCode.SYS_EXCEPTION, errMsg, ex.getMessage());
        }
        
        @ExceptionHandler(Exception.class)
        @ResponseStatus(HttpStatus.EXPECTATION_FAILED)
        @ResponseBody
        ResponseContent handleException(HttpServletRequest req, Exception ex) {
        	if (ex != null) {
        		ex.printStackTrace();
                if (ex instanceof RuntimeException) {
                	return ResponseUtil.errorContent(req, ErrorCode.SYS_EXCEPTION, "RuntimeException", ex.getMessage());
                }
            }
            String errMsg = "undefined exception";
            return ResponseUtil.errorContent(req, ErrorCode.UNDEFINED, errMsg, ex.getMessage());
        }
    }

**注意**：必须保证本类所在的包能够被在springmvc.xml配置文件扫描到

**补充**：为什么要在springMVC中处理异常?当你定义的controller被访问的 时候，如果代码抛出了异常，难道你想让用户看到500的异常信息页面?这里不合理的！所以一般的处理方法是，将异常信息拦截下来，然后友好的返回一些json类型的提示数据即可。这里的ResponseUtil类及errorContent代码由于是公司内部代码，就不做分享了！

## 第十步：创建Controller ##

@RestController
    @RequestMapping("/v1/users")
    public class UserController {
    	@Autowired 
    	private UserService userService;
    
    	
    	@RequestMapping(value = "/{userId}", method = RequestMethod.GET)
    	public ResponseContent getUserInfo(@PathVariable String userId, @RequestParam String token){
    		// 确认Controller方法的url、入参、方法名无误
    
    		// 2.参数校验
    		System.out.println("token : " + token);
    		System.out.println("id : " + userId);
    		if (StringUtil.haveEmptyParams(token)) {
    			throw new IllegalArgumentException("token is empty");
    		}
    		
    		// 3.执行service层方法
    		ResponseContent content = userService.getUserInfo(userId);
    		// 4.返回参数非空校验
    		if (content == null) {
    			throw new ValidateFailureException("用户logic_id编号为 ： [ " + userId + " ]的用户不存在" );
    		}
    		// 5.返回结果
    		return content;
    	}
    	
    }

**注意：**这里方法的返回值类型ResponseContent是接口返回数据的封装类，如无特殊需求，可以将它改实体类类型(如这里的SysUser即可)

## 第十一步：配置web.xml文件 ##

<filter>
    	  <filter-name>characterEncoding</filter-name>
    	  <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
      <init-param>
    	  <param-name>encoding</param-name>
    	  <param-value>UTF-8</param-value>
      </init-param>
      </filter>
      
      <filter-mapping>
    	  <filter-name>characterEncoding</filter-name>
    	  <url-pattern>/*</url-pattern>
      </filter-mapping>
      
       
         <listener>
            <listener-class>org.apache.logging.log4j.web.Log4jServletContextListener</listener-class>
         </listener>
         <filter>
             <filter-name>log4jServletFilter</filter-name>
            <filter-class>org.apache.logging.log4j.web.Log4jServletFilter</filter-class>
         </filter>
         <filter-mapping>
             <filter-name>log4jServletFilter</filter-name>
             <url-pattern>/*</url-pattern>
            <dispatcher>REQUEST</dispatcher>
             <dispatcher>FORWARD</dispatcher>
             <dispatcher>INCLUDE</dispatcher>
             <dispatcher>ERROR</dispatcher>
         </filter-mapping>
         
         
           
         <filter>  
            <filter-name>httpPutFormFilter</filter-name>  
            <filter-class>org.springframework.web.filter.HttpPutFormContentFilter</filter-class>  
        </filter>  
        <filter-mapping>  
            <filter-name>httpPutFormFilter</filter-name>  
            <url-pattern>/*</url-pattern>
        </filter-mapping>
    	
    	
      
      <listener>
     	 <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
      </listener>
      <context-param>
    	  <param-name>contextConfigLocation</param-name>
    	  <param-value>classpath:spring/applicationContext*.xml</param-value>
      </context-param>
      
      
      <servlet>
    	  <servlet-name>springmvc</servlet-name>
    	  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    	  <load-on-startup>1</load-on-startup>
    	   <init-param>
    		   <param-name>contextConfigLocation</param-name>
    		   <param-value>classpath:spring/springmvc.xml</param-value>   
    	   </init-param>
      </servlet>
      
      <servlet-mapping>
      	<servlet-name>springmvc</servlet-name>
      	
      	<url-pattern>/</url-pattern>
      </servlet-mapping>

注意：将各个配置文件所在路径改为你的项目配置文件所在路径即可

## 第十二步：使用eclipse启动本项目： ##

项目右键 -- --> Run As -- --> Maven Builder --输入指令--> tomcat7:run 即可启动项目

## 第十三步：测试接口返回数据 ##

在浏览器中输入：http://localhost:8080/v1/users/ **用户编号**

如果看到有数据返回，说明这次整合成功了！

**说在最后：**貌似此次项目并未加上PageHelper的使用，但是关于插件的环境已经搭好，如需分页查询数据，在查询方法前调用PageHelper.startPage()方法即可！

[log4j2]: http://blog.csdn.net/autfish/article/details/51203709
[Mapper-generator]: http://download.csdn.net/download/zjq852533445/10029375