maven+SSM框架工程搭建

最新推荐文章于 2024-07-18 01:38:16 发布

破z晓

最新推荐文章于 2024-07-18 01:38:16 发布

阅读量518

点赞数

本文链接：https://blog.csdn.net/qq_19688207/article/details/114578526

版权

1、自行下载 maven 和 tomcat 安装配置环境变量（网上查找资料即可）

2、新建工程

选择Maven Project 之后选择next

到如下界面选择webapp

创建 Artifact Id(模块id)

3、使用eclipse 集成maven

Window --- Preferences --- Maven(可搜索) --- Installations

配置User Settings(下载的依赖文件所在位置)

设置 maven conf文件夹下的settings.xml文件配置存放maven仓库的位置，C:/Java_Web/apache-maven-3.5.3/repository 为存放路径

4、配置tomcat

Window --- Preferences --- Server(可搜索) --- Runtime Environments

选择下载或者安装后的tomcat

5、配置pom.xml和web.xml文件，然后等待jar包下载

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>cn.temptation</groupId>
    <artifactId>ssm</artifactId>
    <packaging>war</packaging>
    <version>0.0.1-SNAPSHOT</version>
    <name>ssm Maven Webapp</name>
    <url>http://maven.apache.org</url>
    <properties>
        <!-- Spring版本号 -->
        <spring.version>4.3.8.RELEASE</spring.version>
    </properties>
    <dependencies>
        <!-- Spring相关包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</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-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- AOP相关包 -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.8.0</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.0</version>
        </dependency>

        <!-- MyBatis相关包 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.3.0</version>
        </dependency>
        <!-- MySQL相关包 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.26</version>
        </dependency>
        <!-- 数据库连接池-druid方式 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.12</version>
        </dependency>
        
		<!-- 数据库连接池-dbcp2方式 -->
		<dependency>
    		<groupId>org.apache.commons</groupId>
    		<artifactId>commons-dbcp2</artifactId>
    	<version>2.1.1</version>
		</dependency>
	
        <!-- Spring集成MyBatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.2.3</version>
        </dependency>

        <!-- 
        	添加<scope>provided</scope>，
        	因为provided表明该包只在编译和测试的时候用，
        	所以，当启动tomcat的时候，就不会冲突了，完整依赖如下：
        -->
        <dependency> 
   			<groupId>javax.servlet</groupId> 
   			<artifactId>servlet-api</artifactId> 
   			<version>2.5</version> 
   			<scope>provided</scope> 
		</dependency>

        <!-- 日志相关包 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.21</version>
        </dependency>
        
        <!-- 使用json需要用到的jar包 fastjson/Gson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.62</version>
        </dependency>
        <!--springMVC需要的json包-->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.9.7</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.9.7</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.7</version>
        </dependency>
        <!-- 文件上传使用的jar包 -->
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.3.3</version>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.5</version>
        </dependency>

        <!-- 单元测试相关包 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <finalName>ssm</finalName>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
  <display-name>MyBatis_CRUD</display-name>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
  
  <!-- Spring容器加载 -->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!-- 配置加载Spring文件的监听器-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:SpringConf.xml</param-value>
  </context-param>
  <!-- 配置log4j日志 -->
  <listener> 
  	<listener-class>org.springframework.web.util.Log4jConfigListener</listener-class> 
  </listener>
  
  <!-- SpringMVC的前端控制器 -->
  <servlet>
  	<servlet-name>MyDispatcher</servlet-name>
  	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
 	<!-- SpringMVCp配置文件路径 -->
 	<init-param>
 		<param-name>contextConfigLocation</param-name>
 		<param-value>classpath:SpringMVC-servlet.xml</param-value>
 	</init-param>  
 	<!-- 何时启动，大于0的值表示容器启动时初始化此servlet,正值越小优先级越高 -->
	<load-on-startup>1</load-on-startup>
  </servlet>

  <!-- SpringMVC拦截设置 -->
  <servlet-mapping>
  	<servlet-name>MyDispatcher</servlet-name>
  	<!-- 由SpringMVC拦截所有请求 -->
  	<url-pattern>/</url-pattern>
  </servlet-mapping>
  
  <!-- tomocat自带的编码过滤 - 解决中文乱码问题 -->
    <filter>
        <filter-name>encoding</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>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
  
</web-app>

6、创建项目目录

7、java文件夹下文件内容

UserController.java

package chy.controller;

import javax.annotation.Resource;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import chy.entity.User;
import chy.service.UserServiceImpl;

@Controller
@RequestMapping("/web")
public class UserController {

	@Resource
	private UserServiceImpl serviceImpl;
	
	/**
	 * 用户登录
	 * */
	@RequestMapping(value="/login", method=RequestMethod.POST)
	@ResponseBody// 将java对象转为json格式的数据。
	public String loginUser(@RequestParam("username")String username,
			@RequestParam("password")String password) {
		// 设置值	
		User user = new User();
		user.setUsername(username);
		user.setPassword(password);
		
		int flag = serviceImpl.loginVerification(user);
		if (flag <= 0) {
			System.out.println("失败");
			return "error";
		}
		
		System.out.println("成功！");
		return "success";
	}
	
	/**
	 * 用户注册
	 * */
	@RequestMapping(value="/register", method=RequestMethod.POST)
	@ResponseBody
	public String registerUser(User user) {
				
		serviceImpl.registerUser(user);
		
		return "success";
	}

	/**
	 * 根据fid更新用户
	 * */
	@RequestMapping(value="/updateUser", method=RequestMethod.POST)
	@ResponseBody
	public String updateUserByFid(User user) {
		
		serviceImpl.updateUser(user);
		
		return "success";
	}
	
	/**
	 * 根据fid删除用户
	 * */
	@RequestMapping(value="/deleteUser", method=RequestMethod.POST)
	@ResponseBody
	public String delUserByFid(@RequestParam("fid")String fid) {
		
		serviceImpl.delUser(Integer.parseInt(fid));
		
		return "success";
	}
	
	
	// 查询用户全部数据
	@RequestMapping("/showInfo")
	@ResponseBody
	public String getUsers(ModelMap map){
		map.addAttribute("users",serviceImpl.queryAll());
		System.out.println(map.get("users"));
		
		return "userInfo";
	}

    // 上传文件(上传到服务端)
    @RequestMapping(value="/upload",method=RequestMethod.POST)
	@ResponseBody
	public String upLoadFile(@RequestParam("file") MultipartFile upFile,
			@RequestParam("name") String name,
			@RequestParam("age") String age,
			HttpServletRequest request,
			HttpServletResponse response) {
		
		System.out.println(upFile.getName());
		System.out.println(name);
		System.out.println(age);
		
		// 判断文件手否有内容
		if (!upFile.isEmpty()) {
			// 先设定一个放置上传文件的文件夹(该文件夹可以不存在，下面会判断创建)
			String deposeFilesDir = "C:\\Users\\admin\\Desktop\\file\\";
			// 获取附件原名(有的浏览器如chrome获取到的是最基本的含 后缀的文件名,如myImage.png)
			// 获取附件原名(有的浏览器如ie获取到的是含整个路径的含后缀的文件名，如C:\\Users\\images\\myImage.png)
			String fileName = upFile.getOriginalFilename();
			// 如果是获取的含有路径的文件名，那么截取掉多余的，只剩下文件名和后缀名
			int index = fileName.lastIndexOf("\\");
			if (index > 0) {
				fileName = fileName.substring(index + 1);
			}
			// 判断单个文件大于1M
			long fileSize = upFile.getSize();
			if (fileSize > 1024 * 1024) {
				System.out.println("文件大小为(单位字节):" + fileSize);
				System.out.println("该文件大于1M");
			}
			// 当文件有后缀名时
			if (fileName.indexOf(".") >= 0) {
				// split()中放正则表达式; 转义字符"\\."代表 "."
				String[] fileNameSplitArray = fileName.split("\\.");
				// 加上random戳,防止附件重名覆盖原文件
				fileName = fileNameSplitArray[0] + (int) (Math.random() * 100000) + "." + fileNameSplitArray[1];
			}
			// 当文件无后缀名时(如C盘下的hosts文件就没有后缀名)
			if (fileName.indexOf(".") < 0) {
				// 加上random戳,防止附件重名覆盖原文件
				fileName = fileName + (int) (Math.random() * 100000);
			}
			System.out.println("fileName:" + fileName);
	 
			// 根据文件的全路径名字(含路径、后缀),new一个File对象dest
			File dest = new File(deposeFilesDir + fileName);
			// 如果该文件的上级文件夹不存在，则创建该文件的上级文件夹及其祖辈级文件夹;
			if (!dest.getParentFile().exists()) {
				dest.getParentFile().mkdirs();
			}
			try {
				// 将获取到的附件file,transferTo写入到指定的位置(即:创建dest时，指定的路径)
				upFile.transferTo(dest);
			} catch (IllegalStateException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("文件的全路径名字(含路径、后缀)>>>>>>>" + deposeFilesDir + fileName);
			
			return "success";
		}
		
			
		return "error";
		
	}

    /**
	 * 下载文件（下载到客户端）
	 */
	@RequestMapping(value = "/download",method = RequestMethod.GET)
    @ResponseBody
    public void getFile(@RequestParam("fileName") String fileName,
    		HttpServletRequest request, 
    		HttpServletResponse response) {
		//String fileName = "test.jpg";
		
		// 文件名转码，避免中文乱码  
		String codeFileName = null; 
		try { 
			codeFileName = URLEncoder.encode(fileName,"UTF-8"); 
			} 
		catch (UnsupportedEncodingException e1) { 
			// TODO Auto-generated catch block e1.printStackTrace(); }
		}
		 /* 
		 * 
		 * tomcat_path -- E:/apache-tomcat-8/webapps/SSM/file
		 *  
		 *String tomcat_path = request.getSession().getServletContext().getRealPath("file"); 
		 * 
		 */
		// 文件路径(fileName 传递过来的文件名) 
		String downloadFilePath = "C:\\Users\\admin\\Desktop\\file\\"+codeFileName;
		
		
        File imageFile = new File(downloadFilePath);
        if (imageFile.exists()) {
            FileInputStream fis = null;
            OutputStream os = null;
            try {
                fis = new FileInputStream(imageFile);
                os = response.getOutputStream();
              
                int count = 0;
                byte[] buffer = new byte[1024 * 8];
               
                while ((count = fis.read(buffer,0,buffer.length)) != -1) {
                    os.write(buffer, 0, count);
                    os.flush();
                }

            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    fis.close();
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
        
    }

	
}

UserService.java

package chy.service;

import java.util.List;
import chy.entity.User;

public interface UserService{
	// 注册用户
	void registerUser(User user);
	
	// 验证是否登录
	int loginVerification(User user);
	
	// 根据fid更新用户
	void updateUser(User user);
	
	// 根据fid删除用户
	void delUser(int fid);
	
	// 获取全部数据
	List<User> queryAll();
	
}

User.java

package chy.entity;

import java.io.Serializable;

public class User implements Serializable{
	 
	private Integer fid;// fid
	private String name;// 姓名
	private String sex;// 性别
	private String address;// 地址ַ
	private String username;//用户名
	private String password;// 密码
	  
	  
	  public User() {
		  
	  }
	  
	  public User(Integer fid,
			  		String name,
			  		String sex,
			  		String address,
			  		String username,
			  		String password) {
		  
		  this.fid = fid;
		  this.name = name;
		  this.sex = sex;
		  this.address = address;
		  this.username = username;
		  this.password = password;
		  
	  }

	public Integer getFid() {
		return fid;
	}

	public void setFid(Integer fid) {
		this.fid = fid;
	}

	public String getName() {
		return name;
	}

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

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	@Override
	public String toString() {
		return "User [fid=" + fid + ", name=" + name + ", sex=" + sex + ", address=" + address + ", username="
				+ username + ", password=" + password + "]";
	}
	  
	 
	  
}

UserMapper.java

package chy.mapper;

import java.util.List;
import chy.entity.User;

public interface UserMapper {
	
	void registerUser(User user);// 注册用户
	public int loginVerification(User user);// 验证是否登录
	void updateUser(User user);// 根据fid修改用户
	void deleteUser(int fid);// 根据fid删除用户
	public List<User> getAllUser();// 获取所有数据
}

UserServiceImpl.java

package chy.serviceimpl;

import java.util.List;
import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import chy.entity.User;
import chy.mapper.UserMapper;
import chy.service.UserService;

@Service
public class UserServiceImpl implements UserService{

	@Resource
	private UserMapper userMapper;
	
	// 注册用户
	@Override
	public void registerUser(User user) {
		// TODO Auto-generated method stub
		userMapper.registerUser(user);
		
	}
	
	// 验证是否登录
	@Override
	public int loginVerification(User user) {
		// TODO Auto-generated method stub
		return userMapper.loginVerification(user);
	}
	
	// 根据fid更新用户
	@Override
	public void updateUser(User user) {
		// TODO Auto-generated method stub
		userMapper.updateUser(user);
	}
	
	// 根据fid删除用户
	@Override
	public void delUser(int fid) {
		// TODO Auto-generated method stub
		userMapper.deleteUser(fid);
	}
	
	
	// 获取全部数据
	public List<User> queryAll() {
		// TODO Auto-generated method stub
		return userMapper.getAllUser();
	}


}

8、resources文件夹下文件内容

userMapper.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,namespace习惯上设置成包名+sql映射文件名 
	例如：namespace="com.chy.mapping.userMapper"就是com.chy.mapping（包名）+userMapper(userMapper.xml文件名去掉后缀)
-->
<!-- namespace:此时用mapper代理方式，它的值必须等于对应的mapper接口类的全限名 -->
<mapper	namespace="chy.mapper.UserMapper">
	<!-- 开启本mapper的namespace的二级缓存(对应的User类必须实现Serializable接口,实现序列化，为了将来反序列化) -->
	<cache />
	<!-- 
		在select标签中编写查询的SQL语句，设置select标签的id属性为getUser，
		id属性值必须是唯一的，不能够重复
		使用parameterType属性指明查询时使用的参数类型，resultType属性指明查询返回
		的结果集类型，resultType="com.chy.model.User"
		表示将查询结果封装成User对象返回
	 -->
	 
	 <!-- 根据User对象查询数据库中是否存在该数据 -->
	<select id="loginVerification" parameterType="chy.entity.User"
		resultType="int">
		select count(*) from users where username=#{username} and password=#{password}
	</select>


    <!-- 根据id查询得到一个User对象 -->
	<select id="selectUserById" parameterType="int"
		resultType="chy.entity.User">
		select * from users where fid=#{fid}
	</select>
	
	
	<!-- 查询全部用户 -->
	<select id="getAllUser" resultType="chy.entity.User">
		select * from users
	</select>
	
	<!-- 创建用户(Create) -->
	<insert id="registerUser" parameterType="chy.entity.User">
		insert into users (name, sex, address,username, password) value (#{name}, #{sex}, #{address}, #{username}, #{password})
	</insert>
	

	<!-- 删除用户(Remove) -->
	<delete id="deleteUser" parameterType="int">
		delete from users where fid=#{fid}
	</delete>
	
	
	<!-- 更加fid修改用户(Update) -->
	<update id="updateUser" parameterType="chy.entity.User">
		update users set name=#{name}, sex=#{sex}, address=#{address}, username=#{username}, password=#{password} where fid=#{fid}
	</update>
	
	<!-- 
		清空数据表 
	 deleate 是逐条删除，速度比truncate慢，因为deleate每删除一行
	 需要写mysql日志，但是相对安全写，
	     清空后自增主键不重新开始
	   (jdbc.url 后增加 &allowMultiQueries=true才可以执行多条语句)
   	      （需要在mysqlDB.properties中配置）
	-->
	<delete id="deleteAllUser" >
		delete from users;
		alter table users auto_increment = 1;
	</delete>
	<!-- 
		清空数据表
	truncate整体删除，不写mysql日志，速度比deleate快,
	   清空后，自增id重新开始计数
	 -->
	<delete id="truncateAllUser">
		truncate table users
	</delete>
	
</mapper>

db.properties

jdbc.driver=com.mysql.jdbc.Driver
<!--
	jdbc.url 后增加 &allowMultiQueries=true
	可以在userMapper.xml中执行多条语句。
	例子请看userMapper.xml中id="deleteAllUser"
-->
jdbc.url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8&allowMultiQueries=true
jdbc.username=root
jdbc.password=root
#定义初始连接数  
jdbc.initialSize=0
#定义最大连接数  
jdbc.maxTotal=20
#定义最大空闲  
jdbc.maxIdle=20
#定义最小空闲  
jdbc.minIdle=1
#定义最长等待时间  
jdbc.maxWaitMillis=60000
#空闲回收期运行周期（60秒）
jdbc.timeBetweenEvictionRunsMillis=60000

log4j.properties

### Log4j配置 ### 
### 与Spring结合需要在web.xml中指定此文件位置，并添加监听器 ### 
#定义log4j的输出级别和输出目的地（目的地可以自定义名称，和后面的对应） 
#[ level ] , appenderName1 , appenderName2
log4j.rootLogger=DEBUG,console,file 


#-----------------------------------# 
#1 定义日志输出目的地为控制台
log4j.appender.console = org.apache.log4j.ConsoleAppender 
log4j.appender.console.Target = System.out 
log4j.appender.console.Threshold=DEBUG 
####可以灵活地指定日志输出格式，下面一行是指定具体的格式 ### 
#%c: 输出日志信息所属的类目，通常就是所在类的全名 
#%m: 输出代码中指定的消息,产生的日志具体信息 
#%n: 输出一个回车换行符，Windows平台为"/r/n"，Unix平台为"/n"输出日志信息换行
log4j.appender.console.layout = org.apache.log4j.PatternLayout 
log4j.appender.console.layout.ConversionPattern=[%c]-%m%n 

#-----------------------------------# 
#2 文件大小到达指定尺寸的时候产生一个新的文件 
log4j.appender.file = org.apache.log4j.RollingFileAppender 
#日志文件输出目录 
log4j.appender.file.File=log/tibet.log 
#定义文件最大大小 
log4j.appender.file.MaxFileSize=10mb 
###输出日志信息### 
#最低级别 
log4j.appender.file.Threshold=ERROR 
log4j.appender.file.layout=org.apache.log4j.PatternLayout 
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n 

#-----------------------------------# 
#3 druid 
log4j.logger.druid.sql=INFO 
log4j.logger.druid.sql.DataSource=info 
log4j.logger.druid.sql.Connection=info 
log4j.logger.druid.sql.Statement=info 
log4j.logger.druid.sql.ResultSet=info 


#4 mybatis 显示SQL语句部分 
log4j.logger.org.mybatis=DEBUG 
#log4j.logger.cn.tibet.cas.dao=DEBUG 
#log4j.logger.org.mybatis.common.jdbc.SimpleDataSource=DEBUG# 
#log4j.logger.org.mybatis.common.jdbc.ScriptRunner=DEBUG# 
#log4j.logger.org.mybatis.sqlmap.engine.impl.SqlMapClientDelegate=DEBUG# 
#log4j.logger.java.sql.Connection=DEBUG
log4j.logger.java.sql=DEBUG 
log4j.logger.java.sql.Statement=DEBUG 
log4j.logger.java.sql.ResultSet=DEBUG 
log4j.logger.java.sql.PreparedStatement=DEBUG

MyBatisConf.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>
	<!-- 
		一级缓存：sqlSession级别缓存(默认开启)
		1.默认会被使用;
		2.必须是在同一个sqlSession;
		3.查询条件必须一样;
		4.没有执行sqlSession.clearCache()清理缓存;
		5没有执行怎删改操作（这些操作会清理缓存）;
 	-->
	<!-- 
		二级缓存常用属性：
		<cache 
		eviction="FIFO" 回收策略先进先出
		flushInterval="60000" 自动刷新时间60s
		size="1024" 最多缓存1024个对象
		readOnly="true" 只读
		/>
		二级缓存说明：
		1.二级缓存是mapper(namespace)级别缓存;
		2.User类必须实现Serializable接口,实现序列化，为了将来反序列化;
		3.sqlSession.commit()方法必须执行后二级缓存才会起作用
		在某某mapper.xml文件中开始二级缓存,例子如下：
		<mapper namespace="***">
			<cache />
		</mapper>
			
	-->
	<settings>
		<!-- 配置log4j日志 -->
		<setting name="logImpl" value="LOG4J" />
		<!-- 对此文件下的cache进行全局性开关设置 -->
		<setting name="cacheEnabled" value="true" />
	</settings>
	

	<!-- 配置映射类的别名 -->
	<typeAliases>
		<typeAlias alias="User" type="chy.entity.User" />
	</typeAliases>
	<!-- 注册userMapper.xml文件 -->
	<mappers>
		<mapper resource="mapping/userMapper.xml" />
	</mappers>
</configuration>

SpringConf.xml

<?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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"    
    xmlns:aop="http://www.springframework.org/schema/aop"   
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans   
    http://www.springframework.org/schema/beans/spring-beans-4.1.xsd   
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-4.1.xsd
    http://www.springframework.org/schema/aop   
    http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">  

	 <!-- spring 注解 扫描除了Controller之外的其他组件 -->
	<context:annotation-config/>
	<context:component-scan base-package="chy.*"/> 
	
	
	<!-- 引入db.properties文件 -->
	<context:property-placeholder location="classpath:db.properties" />
	<!-- 配置数据源 - druid方式 -->
	<!-- <bean id="dataSource"
		class="com.alibaba.druid.pool.DruidDataSource"
		init-method="init" destroy-method="close">
		<property name="driverClassName" value="${jdbc.driver}" />
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
		配置初始化大小、最小、最大连连接数量
        <property name="initialSize" value="5"/>
        <property name="minIdle" value="10"/>
        <property name="maxActive" value="20"/>

       	配置获取连接等待超时的时间
        <property name="maxWait" value="60000"/>
       	 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
        <property name="timeBetweenEvictionRunsMillis" value="2000"/>
       	配置一个连接在池中最小生存的时间，单位是毫秒
        <property name="minEvictableIdleTimeMillis" value="600000"/>
       	配置一个连接在池中最大生存的时间，单位是毫秒
        <property name="maxEvictableIdleTimeMillis" value="900000"/>
        validationQuery 用来检测连接是否有效的 sql，要求是一个查询语句，常用 select 'x'。
            	但是在 oracle 数据库下需要写成 select 'x' from dual 不然实例化数据源的时候就会失败,
            	这是由于 oracle 和 mysql 语法间的差异造成的
        <property name="validationQuery" value="select 'x'"/>
        	建议配置为 true，不影响性能，并且保证安全性。申请连接的时候检测，
        	如果空闲时间大于 timeBetweenEvictionRunsMillis，执行 validationQuery 检测连接是否有效。
        <property name="testWhileIdle" value="true"/>
        	申请连接时执行 validationQuery 检测连接是否有效，做了这个配置会降低性能。
        <property name="testOnBorrow" value="false"/>
        	归还连接时执行 validationQuery 检测连接是否有效，做了这个配置会降低性能。
        <property name="testOnReturn" value="false"/>
        	连接池中的 minIdle 数量以内的连接，空闲时间超过 minEvictableIdleTimeMillis，则会执行 keepAlive 操作。
        <property name="keepAlive" value="true"/>
        <property name="phyMaxUseCount" value="100000"/>
       	 配置监控统计拦截的 filters Druid 连接池的监控信息主要是通过 StatFilter 采集的，
       	 采集的信息非常全面，包括 SQL 执行、并发、慢查、执行时间区间分布等
        <property name="filters" value="stat"/>
	</bean> -->
	
	<!-- 数据库连接池 - dbcp方式 -->
	<bean id="dataSource"
		class="org.apache.commons.dbcp2.BasicDataSource"
		destroy-method="close">
		<property name="driverClassName" value="${jdbc.driver}" />
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
		<!-- 初始化连接大小 -->
	    <property name="initialSize" value="${jdbc.initialSize}"/>
	    <!-- 连接池最大数量 -->
	    <property name="maxTotal" value="${jdbc.maxTotal}"/>
	    <!-- 连接池最大空闲 -->
	    <property name="maxIdle" value="${jdbc.maxIdle}"/>
	    <!-- 连接池最小空闲 -->
	    <property name="minIdle" value="${jdbc.minIdle}"/>
	    <!-- 获取连接最大等待时间 -->
	    <property name="maxWaitMillis" value="${jdbc.maxWaitMillis}"/>
	    <!-- 运行一次空闲连接回收器的时间间隔（60秒）-->
	    <property name="timeBetweenEvictionRunsMillis" value="${jdbc.timeBetweenEvictionRunsMillis}"/>
	    <!-- 指明连接是否被空闲连接回收器(如果有)进行检验 -->
	    <property name="testWhileIdle" value="true"/>
	    <!-- 验证时使用的SQL语句 -->
	    <property name="validationQuery" value="SELECT 1" />
	    <!-- 借出连接时不要测试，否则很影响性能 -->
	    <property name="testOnBorrow" value="false"/>
	</bean>
	
	
	<!-- 配置sqlSessionFactory工厂 -->
	<bean id="sqlSessionFactory"
		class=" org.mybatis.spring.SqlSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="configLocation" value="classpath:MyBatisConf.xml" />
	</bean>
	
	<!-- 为useMapper接口类注入sqlSessionFactory -->
	<bean id="userMapper"
		class="org.mybatis.spring.mapper.MapperFactoryBean">
		<property name="mapperInterface" value="chy.mapper.UserMapper" />
		<property name="sqlSessionFactory" ref="sqlSessionFactory" />
	</bean>
		
	
	
</beans>

SpringMVC-servlet.xml

<?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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"    
    xmlns:aop="http://www.springframework.org/schema/aop"   
    xmlns:mvc="http://www.springframework.org/schema/mvc" 
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans   
    http://www.springframework.org/schema/beans/spring-beans-2.5.xsd   
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-2.5.xsd
    http://www.springframework.org/schema/aop   
    http://www.springframework.org/schema/aop/spring-aop-2.5.xsd   
    http://www.springframework.org/schema/tx   
    http://www.springframework.org/schema/tx/spring-tx-2.5.xsd 
    http://www.springframework.org/schema/mvc  
    http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd">  
	
	
	<!-- springMVC容器只扫描Controller -->
	<context:component-scan base-package="chy.controller"/> 
	
	<!-- 解决前台json格式数据中文显示为问号 -->
	<mvc:annotation-driven>
    	<mvc:message-converters register-defaults="true">
        	<bean class="org.springframework.http.converter.StringHttpMessageConverter">
            	<property name="supportedMediaTypes" value="text/html;charset=UTF-8"/>
        	</bean>
    	</mvc:message-converters>
	</mvc:annotation-driven>	
	
	<!-- 对模型试图名称解析，即在模型试图名称添加前缀和后缀 -->
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" 
		p:prefix="/WEB-INF/webs/" p:suffix=".jsp"	/>
	<!-- 
		另一种方式 
		<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
			<property name="prefix" value="/WEB-INF/views/" />
			<property name="suffix" value=".jsp" />
		</bean>
	-->	 	 
	<!-- 配置文件上传视图解析器 -->
	<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
		<!-- maxUploadSize限制上传图片最大字节为5MB,5*1024*1024 -->
		<property name="maxUploadSize" value="5242880"></property>
		<!-- defaultEncoding设置上传图片编码 -->
		<property name="defaultEncoding" value="utf-8"></property>
	</bean>
		

</beans>

9、jsp文件内容

index.jsp（默认首界面）

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
 <!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
</head>
<body>
	<h2>Hello World!</h2>
	<a href="web/showInfo"><button>获取数据库中全部数据</button></a>
	
	<br/>
	 <h2 style="color: red">登录测试</h2><br>
	 <form id="userLogin" method="post" action="web/login" enctype="multipart/form-data">
	  	用户名:<input type="text" name="username"><br>
	   	密 码:<input type="text" name="password"><br>
	     <input type="submit" value="提交">
 	</form>
 	
	<br/>
	 <h2 style="color: red">注册用户</h2><br>
	 <form id="register" method="post" action="web/register" enctype="multipart/form-data">
	  	姓 名:<input type="text" name="name"><br>
	  	性 别:<input type="text" name="sex"><br>
	  	地址:<input type="text" name="address"><br>
	  	用户名:<input type="text" name="username"><br>
	   	密 码:<input type="text" name="password"><br>
	     <input type="submit" value="提交">
 	</form>
 	
 	<br/>
	 <h2 style="color: red">根据fid删除用户</h2><br>
	 <form id="del" method="post" action="web/deleteUser" enctype="multipart/form-data">
	  	fid:<input type="text" name="fid"><br>
	     <input type="submit" value="提交">
 	</form>
 	
 	<br/>
	 <h2 style="color: red">根据fid更新用户</h2><br>
	 <form id="update" method="post" action="web/updateUser" enctype="multipart/form-data">
	  	fid:<input type="text" name="fid"><br>
  		姓 名:<input type="text" name="name"><br>
	  	性 别:<input type="text" name="sex"><br>
	  	地址:<input type="text" name="address"><br>
	  	用户名:<input type="text" name="username"><br>
	   	密 码:<input type="text" name="password"><br>
	     <input type="submit" value="提交">
 	</form>
 	
</body>
</html>

userInfo.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!-- c标签所需引用 -->
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<!DOCTYPE html>
 <html>
 <head>
 <meta charset="UTF-8">
 <title>Insert title here</title>
 </head>
 <body>
     <c:forEach var="user" items="${users}">
    	 姓名:${user.username} 密码:${user.password}
     </c:forEach>
 </body>
 </html>