ssj项目搭建

ssj项目搭建

一，新建一个maven项目

二，引入相关的依赖资源“pom文件”，以及生成web.xml文件

1.生成web.xml文件

<?xml version="1.0" encoding="UTF-8"?> yyc_cup index.html index.htm index.jsp default.html default.htm default.jsp

  <context-param>
   <param-name>contextConfigLocation</param-name>
   <param-value>classpath:applicationContext.xml</param-value>
  </context-param>
  
  <!--配置Spring的监听-->
  <listener>
   <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  
  
  <!-- 配置SpringMVC的核心控制器  拦截所有请求 -->
  <servlet>
   <servlet-name>springMVC</servlet-name>
   <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
   <init-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:springMVC.xml</param-value>
   </init-param>
   <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
   <servlet-name>springMVC</servlet-name>
   <url-pattern>/</url-pattern>
  </servlet-mapping>
  
  
  <!-- 配置编码过滤器,作用:防止中文乱码 -->
  <filter>
   <filter-name>abc</filter-name>
   <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
   <async-supported>true</async-supported>
   <init-param>
    <param-name>encoding</param-name>
    <param-value>utf-8</param-value>
   </init-param>
  </filter>
  <filter-mapping>
   <filter-name>abc</filter-name>
   <url-pattern>/*</url-pattern>
  </filter-mapping>

2.引入相关依赖
因为在此前构建工作空间的时有配置maven所以可以连接阿里云镜像进行下载相关依赖

D:\******** alimaven aliyun maven http://maven.aliyun.com/nexus/content/groups/public/ central org.springframework spring-core ${spring.version} org.springframework spring-context ${spring.version} org.springframework spring-web ${spring.version} org.springframework spring-webmvc ${spring.version}

	  <dependency>
	   <groupId>org.springframework</groupId>
	   <artifactId>spring-orm</artifactId>
	   <version>${spring.version}</version>
	  </dependency>
	  
	  <!-- SpringAOP需要依赖这个jar包 -->
		<dependency>
		    <groupId>org.aspectj</groupId>
		    <artifactId>aspectjweaver</artifactId>
		    <version>1.8.13</version>
		</dependency>
	
	 <!-- 引入servlet -->
	 <dependency>
	  <groupId>javax.servlet</groupId>
	  <artifactId>javax.servlet-api</artifactId>
	  <version>3.1.0</version>
	 </dependency>
	 
	 
	 
	 <!-- SpringMVC文件上传时依赖这个jar包 -->
	  <dependency>
	      <groupId>commons-fileupload</groupId>
	      <artifactId>commons-fileupload</artifactId>
	      <version>1.4</version>
	  </dependency>
	  
	  <!-- 引入Jackson相关依赖 -->
	  <dependency>
	    <groupId>com.fasterxml.jackson.core</groupId>
	    <artifactId>jackson-core</artifactId>
	    <version>2.8.1</version>
	  </dependency>
	  <dependency>
	    <groupId>com.fasterxml.jackson.core</groupId>
	    <artifactId>jackson-databind</artifactId>
	    <version>2.8.1</version>
	  </dependency>
	  <dependency>
	    <groupId>com.fasterxml.jackson.core</groupId>
	    <artifactId>jackson-annotations</artifactId>
	    <version>2.8.1</version>
	  </dependency>
	  
	  <!-- 引入jstl包 -->
		<dependency>
			<groupId>javax.servlet.jsp.jstl</groupId>
			<artifactId>jstl-api</artifactId>
			<version>1.2</version>
			<exclusions>
				<exclusion>
					 <groupId>javax.servlet</groupId>
    				<artifactId>servlet-api</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
		<dependency>
		    <groupId>taglibs</groupId>
		    <artifactId>standard</artifactId>
		    <version>1.1.2</version>
		</dependency>
	  
	  
	  
	  <!-- spring-data-jpa -->
	  <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-jpa</artifactId>
        <version>1.9.0.RELEASE</version>
    </dependency>
    
    <!-- hibernate 配置  4.3.11.Final -->
	  <dependency>
	   <groupId>org.hibernate</groupId>
	   <artifactId>hibernate-core</artifactId>
	   <version>${hibernate.version}</version>
	  </dependency>
	  <dependency>
	   <groupId>org.hibernate</groupId>
	   <artifactId>hibernate-entitymanager</artifactId>
	   <version>${hibernate.version}</version>
	  </dependency>
	  
	  <!-- mysql数据库的驱动包 -->
	  <dependency>
	   <groupId>mysql</groupId>
	   <artifactId>mysql-connector-java</artifactId>
	   <version>5.1.6</version>
	  </dependency>
	  
	  <!-- c3p0数据库连接池 -->
	  <!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
	  <dependency>
	      <groupId>com.mchange</groupId>
	      <artifactId>c3p0</artifactId>
	      <version>0.9.5.2</version>
	  </dependency>
	  
	  <!-- java单元测试框架 -->
	   <dependency>
		    <groupId>junit</groupId>
		    <artifactId>junit</artifactId>
		    <version>4.12</version>
		</dependency>
		<!-- spring 与Junit整合相关依赖 -->
		<dependency>
		    <groupId>org.springframework</groupId>
		    <artifactId>spring-test</artifactId>
		    <version>${spring.version}</version>
		</dependency>
		
		<!-- apache工具包 --> 
		<dependency>
		    <groupId>org.apache.commons</groupId>
		    <artifactId>commons-lang3</artifactId>
		    <version>3.7</version>
		</dependency>
		
		
		 <!-- md5 加密相关依赖 -->
			<dependency>
				<groupId>org.apache.poi</groupId>
				<artifactId>poi</artifactId>
				<version>3.17</version>
			</dependency>
			<dependency>
				<groupId>org.apache.poi</groupId>
				<artifactId>poi-ooxml</artifactId>
				<version>3.17</version>
			</dependency>
			
	<!-- 发送邮件 -->	
	<dependency>
	    <groupId>javax.mail</groupId>
	    <artifactId>mail</artifactId>
	    <version>1.4.7</version>
	</dependency>
	
	<!-- 下载压缩附件 -->
	<dependency>
	    <groupId>org.apache.ant</groupId>
	    <artifactId>ant</artifactId>
	    <version>1.9.7</version>
	</dependency>

三，在resources文件夹中引入applicationContext.xml和springMVC.xml配置文件

1. applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>

 <!-- 1、创建数据源：创建c3p0连接池，连接数据库 -->
 <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
  <property name="driverClass" value="com.mysql.jdbc.Driver" />
   /* 自己的数据库位置 “**** ↓” */
  <property name="jdbcUrl"
   value="jdbc:mysql://localhost:3306/****?useUnicode=true&amp;characterEncoding=UTF-8" />
   
  <property name="user" value="root" />
  <property name="password" value="root" />
 </bean>
 
 
 <!-- 2.根据数据源，创建实体管理工厂 -->
<bean id="entityManagerFactory"
  class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
 <!--  数据源 -->
  <property name="dataSource" ref="dataSource" />
  <!-- 扫描实体类的包  com.fh.model -->
  <property name="packagesToScan" value="com.fh.model" />
  <!-- 指定jpa的提供商 -->
  <property name="persistenceProvider">
   <bean class="org.hibernate.jpa.HibernatePersistenceProvider" />
  </property>
  <!-- JPA的供应商适配器 -->
  <property name="jpaVendorAdapter">
   <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
    <!-- true: HBM2DDL_AUTO为"update" ,有表就维护表，没有表就创建表 false: 默认为false -->
    <property name="generateDdl" value="true" />
    <property name="database" value="MYSQL" />
   <!--  数据库方言：根据这个方言生成不同数据库的sql -->
    <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
    <property name="showSql" value="true" />
   </bean>
  </property>
 <!--  可选：Jpa的方言 -->
  <property name="jpaDialect">
   <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" />
  </property>
 </bean>
 
 <!--  3.配置事务 -->
 <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
  <property name="entityManagerFactory" ref="entityManagerFactory" />
 </bean> 

 <!-- 4.SpringDataJpa的相关配置 
	 base-package:指定基包 
	 entity-manager-factory-ref:引用实体类管理器工厂
   	 transaction-manager-ref： 引用平台事务管理器 -->

<jpa:repositories base-package=“com.fh.repository”
entity-manager-factory-ref=“entityManagerFactory”
transaction-manager-ref=“transactionManager”
/>

<!-- 5、开启组件的扫描 -->
<context:component-scan base-package="com.fh" />

<tx:advice id="txAdvice" transaction-manager="transactionManager">
	<tx:attributes>
		<tx:method name="add*" propagation="REQUIRED" rollback-for="java.lang.Exception" />
		<tx:method name="update*" propagation="REQUIRED"
			rollback-for="java.lang.Exception" />
		<tx:method name="change*" propagation="REQUIRED"
		rollback-for="java.lang.Exception" />
		<tx:method name="delete*" propagation="REQUIRED"
			rollback-for="java.lang.Exception" />
		<tx:method name="save*" propagation="REQUIRED"
			rollback-for="java.lang.Exception" />
		<tx:method name="*" propagation="REQUIRED" read-only="true" />
	</tx:attributes>
</tx:advice>

<!-- 切点配置 execution(* com.fh.service.impl.*.*(..)) 
	第一个*：任意返回值 
	第二个*：包下任意的类 
	第三个*：类中的所有方法 
	(..)：任意参数 -->
<aop:config>
	<aop:pointcut expression="execution(* com.fh.service.impl.*.*(..))"
		id="servicePointcut" />
	<aop:advisor advice-ref="txAdvice" pointcut-ref="servicePointcut" />
</aop:config>

2. springMVC.xml

<?xml version="1.0" encoding="UTF-8"?>

   <!-- 开启注解 补充springmvc注解 -->

mvc:annotation-driven</mvc:annotation-driven>

<context:component-scan base-package=“com.fh.controller”></context:component-scan>

<!-- 放开静态资源 -->
<!--location 配置静态资源的路径    mapping  /** 代表/bootstrap/路径下所有的请求都放开-->
<!-- 为什么配置两颗星？ 
第一个*：bootstrap文件夹下的所有文件  
第二个* ：bootstrap文件夹下的所有文件和文件夹

-->
<mvc:resources location="/bootstrap/" mapping="/bootstrap/**"></mvc:resources>
<mvc:resources location="/js/" mapping="/js/**"></mvc:resources>
<mvc:resources location="/images/" mapping="/images/**"></mvc:resources>



<!-- 配置视图解析器 把handler 方法返回值解析为实际的物理视图 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<!-- prefix前缀  suffix后缀-->
        <property name = "prefix" value="/WEB-INF/view/"></property>
        <property name = "suffix" value = ".jsp"></property>
</bean>


<!-- 上传文件相关配置 -->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
  <!-- 上传文件大小上限，单位为字节（10MB） -->
  <property name="maxUploadSize">
   <value>10485760</value>
  </property>
  <!-- 请求的编码格式，必须和jSP的pageEncoding属性一致，以便正确读取表单的内容，默认为ISO-8859-1 -->
  <property name="defaultEncoding">
   <value>UTF-8</value>
  </property>
 </bean>

四，在webapp中引入bootstrap与js 配置文件

五，在java文件夹下新建一个包com… 包下有model，controller，service，repository层 各层之间相互引用

1. 在model新建一个User类，并使用jpa注解与数据库进行交互，生成表，
   “表结构 ↓”

package .*.model;

import java.util.Date;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

import org.springframework.format.annotation.DateTimeFormat;

@Entity
@Table(name = “u_user”)
public class User {

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
 private Integer userId        ;

 private String username  ;//用户名称
 
 private String password  ;//密码
 
 private Integer age       ;//年龄
 
 private Integer sex       ;//1:男 2:女
 
 @Temporal(TemporalType.DATE)
 @DateTimeFormat(pattern = "yyyy-MM-dd")
 private Date birthday  ;//生日
 
 private String photoPath ;//头像

}

2.编写service与repository接口，
1）repository接口需要继承JpaRepository接口，如果需要进行动态查询等操作的话还需要继承 JpaSpecificationExecutor接口
JpaRepository：
是PagingAndSortingRepository的子接口，增加了一些实用的功能，例如批量操作。
JpaSpecificationExecutor：
用来做负责查询的接口。

package .*.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

import .*.model.User;

public interface UserRepository extends JpaRepository<User, Integer>,JpaSpecificationExecutor {

}

2)，之后创建"service"接口并，编写一个实现类“serviceImpl”用来实现"service"接口后台逻辑代码

package .*.service.impl;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;

import .*.model.Area;
import .*.model.DataTablePageBean;
import .*.model.DataTableResult;
import .*.model.User;
import .*.repository.UserRepository;
import .*.service.UserService;
import .*.util.MD5Util;
import .*.vo.UserQuery;
@Service
public class UserServiceImpl implements UserService {

@Autowired
private UserRepository userRepository;

//分页条件查询
public DataTableResult queryUser(DataTablePageBean pageBean,final UserQuery userQuery) {
	
	Sort sort = new Sort(Direction.DESC, "age");
	PageRequest pageRequest = 
			new PageRequest(pageBean.getStart()/pageBean.getLength(), pageBean.getLength(), sort);
	
	
	Specification specification = new Specification<User>() {

		public Predicate toPredicate(Root<User> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
			ArrayList<Predicate> predicateList = new ArrayList<Predicate>();
			
			if (userQuery != null) {
				
				String username = userQuery.getUsername();
				if (StringUtils.isNotBlank(username)) {
					Predicate predicate = 
							cb.like(root.get("username").as(String.class), "%"+username+"%");
					predicateList.add(predicate);
				}
				
				Area arae = userQuery.getArae();
				if (arae != null && arae.getAreaId() != null && arae.getAreaId() != -1) {
					Predicate predicate 
					= cb.equal(root.get("arae").get("areaId").as(Integer.class), arae.getAreaId());
					predicateList.add(predicate);
				}
				
				Integer sex = userQuery.getSex();
				//因为Integer是包装类所以可以直接进行if判断
				if (sex != null) {
					Predicate predicate 
					= cb.equal(root.get("sex").as(Integer.class), sex);
					predicateList.add(predicate);
				}
				
				Integer age = userQuery.getAge();
				//因为Integer是包装类所以可以直接进行if判断
				if (age != null) {
					Predicate predicate 
					= cb.equal(root.get("age").as(Integer.class), age);
					predicateList.add(predicate);
				}
				
				Date minBirthday = userQuery.getMinBirthday();
				if (minBirthday != null) {
					Predicate predicate 
					//greaterThanOrEqualTo ：greater大于的意思Equal等于
					= cb.greaterThanOrEqualTo(root.get("birthday").as(Date.class), minBirthday);
					predicateList.add(predicate);
				}
				
				Date maxBirthday = userQuery.getMaxBirthday();
				if (maxBirthday != null) {
					Predicate predicate 
					//lessThanOrEqualTo ：less小于的意思Equal等于
					= cb.lessThanOrEqualTo(root.get("birthday").as(Date.class), maxBirthday);
					predicateList.add(predicate);
				}
				
			}
			
			return cb.and(predicateList.toArray(new Predicate[predicateList.size()]));
		}
	};
	
	
	Page<User> page = userRepository.findAll(specification, pageRequest);
	
	DataTableResult dataTableResult = new DataTableResult();
	dataTableResult.setDraw(pageBean.getDraw());
	dataTableResult.setData(page.getContent());
	dataTableResult.setRecordsFiltered(page.getTotalElements());
	dataTableResult.setRecordsTotal(page.getTotalElements());
	
	return dataTableResult;
}

//添加
public User addUser(User user) {
	
	//MD5加密
	user.setPassword(MD5Util.generate(user.getPassword()));
	return userRepository.save(user);
}

//删除
public void deleteUser(Integer userId) {
	userRepository.delete(userId);
}

//回显
public User getByUserId(Integer userId) {
	return userRepository.findOne(userId);
}

//修改
public void updateUser(User user) {
	userRepository.save(user);
}

//批量删除
public List<User> getByUserIds(List<Integer> userIdList) {
	return userRepository.findAll(userIdList);
}
public void deletesBatch(List<User> userList) {
	userRepository.deleteInBatch(userList);
}

}

3.新建一个controller层类，作用于连接前端与后端，接受前端发来的请求，同时向后端发送请求，---->service 层---->serviceImpl实现service层,最后操作数据库

package .*.controller;

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.UUID;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;

import .*.common.Const;
import .*.model.Area;
import .*.model.DataTablePageBean;
import .*.model.DataTableResult;
import .*.model.User;
import .*.service.AreaService;
import .*.service.UserService;
import .*.util.MD5Util;
import .*.util.MyUtil;
import .*.vo.UserQuery;

@Controller
@RequestMapping(“userController”)
public class UserController {

@Autowired
private UserService userService;

/**
* 文件上传
*/
@ResponseBody
@RequestMapping(“uploadFile”)
public Map<String, Object> uploadFile(
@RequestParam(“avatar”)MultipartFile multipartFile,
HttpServletRequest request){
Map<String, Object> result = MyUtil.getMap();

	/**
	 * 修改文件名
	 */
	//获取文件原始名称
	String originalFilename = multipartFile.getOriginalFilename();
	//找出最后一个“.”的索引位置
	int Index = originalFilename.lastIndexOf(".");
	// 按照“.”索引位置进行截取
	String suffix = originalFilename.substring(Index);
	// 使用UUID随机生成字符串 +suffix
	String newFileName = UUID.randomUUID().toString() + suffix;
	
	/**
	 * 保存文件
	 */
	// 获取项目的上下文绝对路径
	String realPath = request.getServletContext().getRealPath("/images");
	// 将绝对路径放入到file对象中
	File file = new File(realPath);
	// 判断文件是否存在，取反
	if (!file.exists()) {
		// 如果不存在，新建一个
		file.mkdir();
	}
	
	try {
		multipartFile.transferTo(new File(realPath + "/" + newFileName));
		result.put("success", true);
		result.put("filePath", "images/" + newFileName);
	} catch (Exception e) {
		result.put("success", false);
		e.printStackTrace();
	}
	
	return result;
}