maven系列：构建maven工程

今天我们来通过一个项目小实战（spring+mybatis），让大家对maven有更加深刻的认知

一）建立maven工程
①右击new-》other-》maven-》Maven Project，然后next、next，填写项目需要的相关信息，点击finish
②修改项目jdk，项目上右击选择properties，进入一窗口
      --点击Java Build Path，修改JRE System Library，选择你安装的jdk。
      --点击Resource，修改字符集为uTF-8
      --点击Java Compiler，修改编译版本为1.7或者1.8（ps：这个跟项目中的spring版本有关，比如我演示用的这个就不能用1.8，要不然报依赖有关的额错误），1.5有点太远古（不过我们这个例子中影响不大）
③我们知道，有了mybatis就是要操作数据库了哈，嗯，肯定涉及到很多数据库配置文件，根据管理，约束？我们都会再建一个包来放这些文件，右击项目-》new-》Source Folder
一顿操作之后项目的目录结构如下
maven系列：构建maven工程

二）添加依赖，我们打开pom.xml文件添加依赖

<!-- spring依赖 -->
                <dependency>
                        <groupId>org.springframework</groupId>
                        <artifactId>spring-core</artifactId>
                        <version>3.2.8.RELEASE</version>
                </dependency>
                <dependency>
                        <groupId>org.springframework</groupId>
                        <artifactId>spring-webmvc</artifactId>
                        <version>3.2.8.RELEASE</version>
                </dependency>
                <dependency>
                        <groupId>org.springframework</groupId>
                        <artifactId>spring-context</artifactId>
                        <version>3.2.8.RELEASE</version>
                </dependency>
                <dependency>
                        <groupId>org.springframework</groupId>
                        <artifactId>spring-context-support</artifactId>
                        <version>3.2.8.RELEASE</version>
                </dependency>
                <dependency>
                        <groupId>org.springframework</groupId>
                        <artifactId>spring-aop</artifactId>
                        <version>3.2.8.RELEASE</version>
                </dependency>
                <dependency>
                        <groupId>org.springframework</groupId>
                        <artifactId>spring-aspects</artifactId>
                        <version>3.2.8.RELEASE</version>
                </dependency>
                <dependency>
                        <groupId>org.springframework</groupId>
                        <artifactId>spring-tx</artifactId>
                        <version>3.2.8.RELEASE</version>
                </dependency>
                <dependency>
                        <groupId>org.springframework</groupId>
                        <artifactId>spring-jdbc</artifactId>
                        <version>3.2.8.RELEASE</version>
                </dependency>
                <dependency>
                        <groupId>org.springframework</groupId>
                        <artifactId>spring-web</artifactId>
                        <version>3.2.8.RELEASE</version>
                </dependency>

                <!--单元测试依赖 -->
                <dependency>
                        <groupId>junit</groupId>
                        <artifactId>junit</artifactId>
                        <version>4.12</version>
                        <scope>test</scope>
                </dependency>
                <dependency>
                        <groupId>org.springframework</groupId>
                        <artifactId>spring-test</artifactId>
                        <version>3.2.8.RELEASE</version>
                        <scope>test</scope>
                </dependency>

                <!-- 日志依赖 -->
                <dependency>
                        <groupId>log4j</groupId>
                        <artifactId>log4j</artifactId>
                        <version>1.2.12</version>
                </dependency>
                <dependency>
                        <groupId>org.slf4j</groupId>
                        <artifactId>slf4j-api</artifactId>
                        <version>1.6.6</version>
                </dependency>
                <dependency>
                        <groupId>org.slf4j</groupId>
                        <artifactId>slf4j-log4j12</artifactId>
                        <version>1.6.6</version>
                </dependency>

                <!--mybatis依赖 -->
                <dependency>
                        <groupId>org.mybatis</groupId>
                        <artifactId>mybatis</artifactId>
                        <version>3.2.1</version>
                </dependency>
                <dependency>
                        <groupId>org.mybatis</groupId>
                        <artifactId>mybatis-spring</artifactId>
                        <version>1.2.0</version>
                </dependency>

                <!-- mysql驱动包 -->
                <dependency>
                        <groupId>mysql</groupId>
                        <artifactId>mysql-connector-java</artifactId>
                        <version>8.0.12</version>
                </dependency>

三）下载msyql数据库，我下载的是最新的8.X，这个去官网下载，然后一路next就好，注意，如果电脑比较新，去下载个c++2015，保证能安装成功
连接数据库的方式有很多中，比如使用三方工具sqlyog，或者使用mysql自带工具：MySQL Workbench……，进去之后我们看下字符集：show variables like 'character%';
新版的mysql安装都是utf8mb4,（5.7的是utf-8），其中utf8mb4更为强大哈，不仅能兼容utf-8，同时支持4字节的表情字符【普通的字符串或者表情占三个字节，移动端的表情符号占四个字节】，腻害了，mysql也是良心企业啊
建立数据库oa，建库语句：create database oa
在建一个表employee，建表语句：
use oa;
CREATE TABLE `employee` (
  `id` int(11) NOT NULL auto_increment,
  `name` varchar(45) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='员工表'

四）写配置文件
application-organ.xml（注意，这个地方没有使用application.xml，是因为如果这个一个单独的小项目，那么可以直接这样命令，我们是打算搞一个大项目的，所以得有所区分）
jdbc.properties（数据库配置文件）
log4j.properties（日志配置文件）
mybatis-config.xml（mybatis配置文件）

五）写java类
实体类：Employee.java
service接口：EmployeeService.java
service实现类：EmployeeServiceImpl.java
dao接口：EmployeeMapper.java
dao实现：我们使用的是文件实现
测试类：EmployeeServiceTest.java

弄好了之后结构如下
maven系列：构建maven工程

六）单元测试
EmployeeServiceTest.java类中右击run-》junit测试，我们发现数据库有数据了哈，ps：程序运行过程中可能回报一个时区有关的异常（set global time_zone='+8:00';处理一下）
我们执行成功，并看下数据库，数据入库了，ok了

maven系列：构建maven工程

代码如下
EmployeeMapper.java

package com.mzlx.oa.organ.mapper;

import com.mzlx.oa.organ.model.Employee;

public interface EmployeeMapper {
        public void addEmployee(Employee employee);
        
        public Employee findEmployeeById(Long id);
}

EmployeeMapper.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.mzlx.oa.organ.mapper.EmployeeMapper">    
    
    <insert id="addEmployee" parameterType="com.mzlx.oa.organ.model.Employee">
            INSERT INTO employee(name,age) VALUES(#{name},#{age})
    </insert>
    
    <select id="findEmployeeById" parameterType="int" resultType="com.mzlx.oa.organ.model.Employee">    
        SELECT * FROM employee WHERE ID=#{id}  
    </select>  
    
</mapper>

Employee.java

package com.mzlx.oa.organ.model;

public class Employee {
        private Long id;
        private String name;
        private Integer age;

        public Long getId() {
                return id;
        }

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

        public String getName() {
                return name;
        }

        public void setName(String name) {
                this.name = name;
        }

        public Integer getAge() {
                return age;
        }

        public void setAge(Integer age) {
                this.age = age;
        }

}

EmployeeService.java

package com.mzlx.oa.organ.service;

import com.mzlx.oa.organ.model.Employee;

public interface EmployeeService {

        public void addEmployee(Employee employee);
        
        public Employee findEmployeeById(Long id);
        
}

EmployeeServiceImpl .java

package com.mzlx.oa.organ.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.mzlx.oa.organ.mapper.EmployeeMapper;
import com.mzlx.oa.organ.model.Employee;
import com.mzlx.oa.organ.service.EmployeeService;

@Service("employeeService")
public class EmployeeServiceImpl implements EmployeeService {

        @Autowired
        private EmployeeMapper employeeMapper;
        
        public void addEmployee(Employee employee) {
                employeeMapper.addEmployee(employee); 
        }

        public Employee findEmployeeById(Long id) {
                return employeeMapper.findEmployeeById(id);
        }

}

EmployeeServiceTest.java

package com.mzlx.oa.organ.service;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.mzlx.oa.organ.model.Employee;

@ContextConfiguration(locations = {"classpath:application-organ.xml"})  
@RunWith(SpringJUnit4ClassRunner.class)  
public class EmployeeServiceTest {
        
        @Autowired
        private EmployeeService employeeService;
        
        @Test
        public void testAddEmployee() {
                Employee employee = new Employee();
                employee.setName("测试");
                employee.setAge(20);
                employeeService.addEmployee(employee);
        }
}

配置文件
application-organ.xml【心细的童鞋可能注意到了，有的地方使用classpath，有的地方使用了classpath*，这是有区别的，其中classpath：只会到你的class路径中查找找文件。classpath*：不仅包含class路径，还包括jar文件中（class路径）进行查找。】

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
    xmlns:aop="http://www.springframework.org/schema/aop"  
    xsi:schemaLocation="    
           http://www.springframework.org/schema/beans    
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd    
           http://www.springframework.org/schema/aop    
           http://www.springframework.org/schema/aop/spring-aop-3.0.xsd  
           http://www.springframework.org/schema/context    
           http://www.springframework.org/schema/context/spring-context-3.0.xsd">  
       
     <!-- jdbc配置文件 -->    
     <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
        <property name="locations">  
            <list>  
               <value>classpath*:jdbc.properties</value>   
            </list>  
        </property>  
    </bean>  
      
    <!-- 配置数据源 -->  
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">  
        <property name="driverClassName" value="${jdbc.driverClassName}" />  
        <property name="url" value="${jdbc.url}" />  
        <property name="username" value="${jdbc.username}" />  
        <property name="password" value="${jdbc.password}" />  
    </bean>  
    
        <!-- 配置mybatis sqlSessionFactory -->          
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">  
        <property name="dataSource" ref="dataSource" />  
        <property name="mapperLocations" value="classpath*:com/mzlx/oa/organ/mapper/**/*.xml"/>    
        <property name="configLocation" value="classpath:mybatis-config.xml" />  
    </bean> 
         
         <!-- 自动扫描mapper接口文件 --> 
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">  
        <property name="basePackage" value="com.mzlx.oa.organ.mapper" />  
    </bean>  
          
    <!-- 自动扫描注解的bean -->  
    <context:component-scan base-package="com.mzlx.oa.organ.service.*" />  
</beans>

jdbc.properties（注意，mysql8的驱动跟5.7以及之前的不一样哦）

#jdbc.driverClassName=com.mysql.jdbc.Driver  
jdbc.driverClassName=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/oa  
jdbc.username=root
jdbc.password=123123123

log4j.properties

log4j.rootLogger=DEBUG,Console,Stdout  
   
log4j.appender.Console=org.apache.log4j.ConsoleAppender  
log4j.appender.Console.layout=org.apache.log4j.PatternLayout  
log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n  
  
log4j.logger.java.sql.ResultSet=INFO  
log4j.logger.org.apache=INFO  
log4j.logger.java.sql.Connection=DEBUG  
log4j.logger.java.sql.Statement=DEBUG  
log4j.logger.java.sql.PreparedStatement=DEBUG

mybatis-config.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>      
</configuration>

补充一下，前面我们使用的是直接运行测试，实际工作中还是看是否能生成可行性jar包
右击项目-》run-》Run Configurations-》配置一下-》run
maven系列：构建maven工程

如果出现BUILD SUCCESS，则表示编译成功
不过上面的代码肯定是失败的，为啥呢，这是一个项目，再也不是一个普通的java类了，所以相关依赖都需要打包才可以呢
解决方案：在pom.xml文件中添加如下标签代码

<build>
                <resources>
                        <resource>
                                <directory>src/main/java</directory>
                                <includes>
                                        <include>**/*.xml</include>
                                </includes>
                                <filtering>true</filtering>
                        </resource>
                        <resource>
                                <directory>src/main/resources</directory>
                                <includes>
                                        <include>**/*.xml</include>
                                        <include>**/*.properties</include>
                                </includes>
                                <filtering>true</filtering>
                        </resource>
                </resources>
        </build>

嗯，之后再run，出现BUILD SUCCESS，编译成功