Spring SSM 框架

时间：2018-04-28 23:49:50 阅读：543 评论：0 收藏：0 [点我收藏+]

标签：云计算参考 slf4j column 高效数据库的操作 hub The war

IDEA 整合 SSM 框架学习

http://www.cnblogs.com/wmyskxz/p/8916365.html
认识 Spring 框架
更多详情请点击这里：这里

Spring 框架是 Java 应用最广的框架，它的成功来源于理念，而不是技术本身，它的理念包括 IoC (Inversion of Control，控制反转) 和 AOP(Aspect Oriented Programming，面向切面编程)。

什么是 Spring：
Spring 是一个轻量级的 DI / IoC 和 AOP 容器的开源框架，来源于 Rod Johnson 在其著作《Expert one on one J2EE design and development》中阐述的部分理念和原型衍生而来。
Spring 提倡以“最少侵入”的方式来管理应用中的代码，这意味着我们可以随时安装或者卸载 Spring
适用范围：任何 Java 应用
Spring 的根本使命：简化 Java 开发
尽管 J2EE 能够赶上 Spring 的步伐，但 Spring 并没有停止前进， Spring 继续在其他领域发展，而 J2EE 则刚刚开始涉及这些领域，或者还没有完全开始在这些领域的创新。移动开发、社交 API 集成、NoSQL 数据库、云计算以及大数据都是 Spring 正在涉足和创新的领域。Spring 的前景依然会很美好。

Spring 的优势
低侵入 / 低耦合（降低组件之间的耦合度，实现软件各层之间的解耦）
声明式事务管理（基于切面和惯例）
方便集成其他框架（如MyBatis、Hibernate）
降低 Java 开发难度
Spring 框架中包括了 J2EE 三层的每一层的解决方案（一站式）
Spring 能帮我们做什么
①.Spring 能帮我们根据配置文件创建及组装对象之间的依赖关系。
②.Spring 面向切面编程能帮助我们无耦合的实现日志记录，性能统计，安全控制。
③.Spring 能非常简单的帮我们管理数据库事务。
④.Spring 还提供了与第三方数据访问框架（如Hibernate、JPA）无缝集成，而且自己也提供了一套JDBC访问模板来方便数据库访问。
⑤.Spring 还提供与第三方Web（如Struts1/2、JSF）框架无缝集成，而且自己也提供了一套Spring MVC框架，来方便web层搭建。
⑥.Spring 能方便的与Java EE（如Java Mail、任务调度）整合，与更多技术整合（比如缓存框架）。

Spring 的框架结构

Data Access/Integration层包含有JDBC、ORM、OXM、JMS和Transaction模块。
Web层包含了Web、Web-Servlet、WebSocket、Web-Porlet模块。
AOP模块提供了一个符合AOP联盟标准的面向切面编程的实现。
Core Container(核心容器)：包含有Beans、Core、Context和SpEL模块。
Test模块支持使用JUnit和TestNG对Spring组件进行测试。
Spring IoC 概述
更多详情请点击这里：这里

IoC：Inverse of Control（控制反转）
读作“反转控制”，更好理解，不是什么技术，而是一种设计思想，就是将原本在程序中手动创建对象的控制权，交由Spring框架来管理。
正控：若要使用某个对象，需要自己去负责对象的创建
反控：若要使用某个对象，只需要从 Spring 容器中获取需要使用的对象，不关心对象的创建过程，也就是把创建对象的控制权反转给了Spring框架
好莱坞法则：Don’t call me ,I’ll call you
一个例子
控制反转显然是一个抽象的概念，我们举一个鲜明的例子来说明。

在现实生活中，人们要用到一样东西的时候，第一反应就是去找到这件东西，比如想喝新鲜橙汁，在没有饮品店的日子里，最直观的做法就是：买果汁机、买橙子，然后准备开水。值得注意的是：这些都是你自己“主动”创造的过程，也就是说一杯橙汁需要你自己创造。

然而到了今时今日，由于饮品店的盛行，当我们想喝橙汁时，第一想法就转换成了找到饮品店的联系方式，通过电话等渠道描述你的需要、地址、联系方式等，下订单等待，过一会儿就会有人送来橙汁了。

请注意你并没有“主动”去创造橙汁，橙汁是由饮品店创造的，而不是你，然而也完全达到了你的要求，甚至比你创造的要好上那么一些。

Spring IoC 阐述
这就是一种控制反转的理念，上述的例子已经很好的说明了问题，我们再来描述一下控制反转的概念：控制反转是一种通过描述（在 Java 中可以是 XML 或者注解）并通过第三方（Spring）去产生或获取特定对象的方式。

好处：
降低对象之间的耦合
我们不需要理解一个类的具体实现，只需要知道它有什么用就好了（直接向 IoC 容器拿）
主动创建的模式中，责任归于开发者，而在被动的模式下，责任归于 IoC 容器，基于这样的被动形式，我们就说对象被控制反转了。（也可以说是反转了控制）

Spring AOP 简介
更多详情请点击这里：这里

如果说 IoC 是 Spring 的核心，那么面向切面编程就是 Spring 最为重要的功能之一了，在数据库事务中切面编程被广泛使用。

AOP 即 Aspect Oriented Program 面向切面编程
首先，在面向切面编程的思想里面，把功能分为核心业务功能，和周边功能。

所谓的核心业务，比如登陆，增加数据，删除数据都叫核心业务
所谓的周边功能，比如性能统计，日志，事务管理等等
周边功能在 Spring 的面向切面编程AOP思想里，即被定义为切面

在面向切面编程AOP的思想里面，核心业务功能和切面功能分别独立进行开发，然后把切面功能和核心业务功能 "编织" 在一起，这就叫AOP

AOP 的目的
AOP能够将那些与业务无关，却为业务模块所共同调用的逻辑或责任（例如事务处理、日志管理、权限控制等）封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可拓展性和可维护性。

一个例子
为了更好的说明 AOP 的概念，我们来举一个实际中的例子来说明：

在上面的例子中，包租婆的核心业务就是签合同，收房租，那么这就够了，灰色框起来的部分都是重复且边缘的事，交给中介商就好了，这就是 AOP 的一个思想：让关注点代码与业务代码分离！

认识 MyBatis 框架
更多详情请点击这里：这里

MyBatis 简介
MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis，是一个基于Java的持久层框架。

持久层：可以将业务数据存储到磁盘，具备长期存储能力，只要磁盘不损坏，在断电或者其他情况下，重新开启系统仍然可以读取到这些数据。
优点：
可以使用巨大的磁盘空间存储相当量的数据，并且很廉价
灵活，几乎可以代替 JDBC，同时提供了接口编程。
缺点：慢（相对于内存而言）
为什么使用 MyBatis
在我们传统的 JDBC 中，我们除了需要自己提供 SQL 外，还必须操作 Connection、Statment、ResultSet，不仅如此，为了访问不同的表，不同字段的数据，我们需要些很多雷同模板化的代码，闲的繁琐又枯燥。

而我们在使用了 MyBatis 之后，只需要提供 SQL 语句就好了，其余的诸如：建立连接、操作 Statment、ResultSet，处理 JDBC 相关异常等等都可以交给 MyBatis 去处理，我们的关注点于是可以就此集中在 SQL 语句上，关注在增删改查这些操作层面上。

并且 MyBatis 支持使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。

认识 Spring MVC 框架
更多详情请点击这里：这里

MVC 设计概述
在早期 Java Web 的开发中，统一把显示层、控制层、数据层的操作全部交给 JSP 或者 JavaBean 来进行处理，我们称之为 Model1：

出现的弊端：
JSP 和 Java Bean 之间严重耦合，Java 代码和 HTML 代码也耦合在了一起
要求开发者不仅要掌握 Java ，还要有高超的前端水平
前端和后端相互依赖，前端需要等待后端完成，后端也依赖前端完成，才能进行有效的测试
代码难以复用
正因为上面的种种弊端，所以很快这种方式就被 Servlet + JSP + Java Bean 所替代了，早期的 MVC 模型（Model2）就像下图这样：

首先用户的请求会到达 Servlet，然后根据请求调用相应的 Java Bean，并把所有的显示结果交给 JSP 去完成，这样的模式我们就称为 MVC 模式。

M 代表模型（Model）
模型是什么呢？模型就是数据，就是 dao,bean
V 代表视图（View）
视图是什么呢？就是网页, JSP，用来展示模型中的数据
C 代表控制器（controller)
控制器是什么？控制器的作用就是把不同的数据(Model)，显示在不同的视图(View)上，Servlet 扮演的就是这样的角色。
扩展阅读：Web开发模式

Spring MVC 的架构
为解决持久层中一直未处理好的数据库事务的编程，又为了迎合 NoSQL 的强势崛起，Spring MVC 给出了方案：

传统的模型层被拆分为了业务层(Service)和数据访问层（DAO,Data Access Object）。在 Service 下可以通过 Spring 的声明式事务操作数据访问层，而在业务层上还允许我们访问 NoSQL ，这样就能够满足异军突起的 NoSQL 的使用了，它可以大大提高互联网系统的性能。

特点：
结构松散，几乎可以在 Spring MVC 中使用各类视图
松耦合，各个模块分离
与 Spring 无缝集成
Spring + Spring MVC + MyBatis 整合开发
认识 Maven
Maven 的翻译为 “专家”、“行家” ，是一个跨平台的项目管理工具。

主要用于：基于 Java 平台的项目（Maven 本身也是 Java 编写的）的构建、依赖包管理和项目信息管理。
Maven 主要用处一：相同的项目结构
Maven 提供了一种标准的项目目录结构，测试命名规则等项目的最佳实践方案，统一了不同项目的学习成本（约定大于配置）：

在 IDEA 下创建一个默认的 Maven 项目，有着上面这样相同的结构：

有一个 pom.xml 用于维护当前项目所依赖的 jar 包
所有的 Java 代码都放在 src/main/java 目录下
所有的测试代码都放在 src/test/java 目录下
Maven 主要用处二：统一维护 jar 包
Maven能提供一种项目的依赖配置，配置好的项目，Maven 能自动的从 Maven 的中央仓库中帮我们下载并管理项目依赖的 jar 包，并且还能自动的管理这些 jar 包依赖的其他 jar 包

比如说有 3 个 Java 项目，这些项目都不是 maven 风格。那么这3个项目，就会各自维护一套jar包。而其中有些jar包是相同的。

而 maven 风格的项目，首先把所有的 jar 包都放在"仓库“ 里，然后哪个项目需要用到这个 jar 包，只需要给出 jar 包的名称和版本号就行了。这样 jar 包就实现了共享

如图所示，在 pom.xml 里，表示用到了 mysql 的jar包，版本号是 5.1.30。

引自：how2j.cn-Maven教程

使用 Maven 构建 SSM 项目
如果对于 Maven 不熟悉的童鞋可以去上面的链接学习一下 Maven 的使用，下面是我配置好了 Maven 的 IDEA 环境下的构建过程。

第一步：创建 Maven webapp 项目
首先新建工程，选择 Maven 标签，然后勾选上【Create from archetype】选择 webapp：

点击下一步，填写上【GroupId】和【ArtifactId】：

GroupId：项目组织唯一的标识符，实际对应 JAVA 的包的结构，也就是 main 目录下 java 的目录结构（包）
AritifactId：项目的唯一标识符，实际对应项目的名称，就是项目根目录的名称
实际上你可以乱填上试试，我就不乱填了

确认项目路径，这一步你可以看到 Maven 配置中的参数，不需要做改动，直接下一步就可以（图中的路径是我配置的本地 Maven 仓库的地址）：

确认项目名称，点击【Finish】即可：

等待一会儿，控制台就会有创建成功的提示信息，我们把【Enable Auto-Import】点上，这个提示会在每次 pom.xml 有改动时出现，自动导入，省掉麻烦：

第二步：搭建项目目录结构
下面就是 Maven 风格的 webapp 的默认目录结构：

注意： webapp 是默认没有 java 源文件也没有 test 目录的。
遵循 Maven 的统一项目结构，我们搭建出项目的完整目录结构如下图：

我们并没有使用 Log4j 来输出日志，而是使用 logback
提示：我们可以在 IDEA 中右键目录然后选择【Make Directory as】，让 IDEA 识别不同的目录作用

这里的目录建好之后还需要设置一下，让 IDEA 识别目录作用，选择【File】>【Project Structure】：

设置好之后点击 OK，即完成了项目目录的搭建。

第三步：配置文件内容
在【pom.xml】文件中声明依赖的 jar 包：

<modelVersion>4.0.0</modelVersion>
<packaging>war</packaging>

<name>SSM</name>
<groupId>cn.wmyskxz</groupId>
<artifactId>SSM</artifactId>
<version>1.0-SNAPSHOT</version>

<build>
    <plugins>
        <plugin>
            <groupId>org.mortbay.jetty</groupId>
            <artifactId>maven-jetty-plugin</artifactId>
            <version>6.1.7</version>
            <configuration>
                <connectors>
                    <connector implementation="org.mortbay.jetty.nio.SelectChannelConnector">
                        <port>8888</port>
                        <maxIdleTime>30000</maxIdleTime>
                    </connector>
                </connectors>
                <webAppSourceDirectory>${project.build.directory}/${pom.artifactId}-${pom.version}
                </webAppSourceDirectory>
                <contextPath>/</contextPath>
            </configuration>
        </plugin>
    </plugins>
</build>

<properties>
    <!-- 设置项目编码编码 -->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <!-- spring版本号 -->
    <spring.version>4.3.5.RELEASE</spring.version>
    <!-- mybatis版本号 -->
    <mybatis.version>3.4.1</mybatis.version>
</properties>

<dependencies>

    <!-- java ee -->
    <dependency>
        <groupId>javax</groupId>
        <artifactId>javaee-api</artifactId>
        <version>7.0</version>
    </dependency>

    <!-- 单元测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>

    <!-- 实现slf4j接口并整合 -->
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.2</version>
    </dependency>

    <!-- JSON -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.8.7</version>
    </dependency>


    <!-- 数据库 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.41</version>
        <scope>runtime</scope>
    </dependency>

    <!-- 数据库连接池 -->
    <dependency>
        <groupId>com.mchange</groupId>
        <artifactId>c3p0</artifactId>
        <version>0.9.5.2</version>
    </dependency>

    <!-- MyBatis -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>${mybatis.version}</version>
    </dependency>

    <!-- mybatis/spring整合包 -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>1.3.1</version>
    </dependency>

    <!-- Spring -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</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-context</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>
    <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-test</artifactId>
        <version>${spring.version}</version>
    </dependency>
    
</dependencies>

在【web.xml】中声明编码过滤器并配置 DispatcherServlet ：

<!-- 编码过滤器 -->
<filter>
    <filter-name>encodingFilter</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>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

<!-- 配置DispatcherServlet -->
<servlet>
    <servlet-name>SpringMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 配置springMVC需要加载的配置文件-->
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-*.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
    <async-supported>true</async-supported>
</servlet>
<servlet-mapping>
    <servlet-name>SpringMVC</servlet-name>
    <!-- 匹配所有请求 -->
    <url-pattern>/</url-pattern>
</servlet-mapping>

在【spring-mybatis.xml】中完成 spring 和 mybatis 的配置：

<!-- 扫描service包下所有使用注解的类型 -->
<context:component-scan base-package="cn.wmyskxz.service"/>

<!-- 配置数据库相关参数properties的属性：${url} -->
<context:property-placeholder location="classpath:jdbc.properties"/>

<!-- 数据库连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="${jdbc.driver}"/>
    <property name="jdbcUrl" value="${jdbc.url}"/>
    <property name="user" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
    <property name="maxPoolSize" value="${c3p0.maxPoolSize}"/>
    <property name="minPoolSize" value="${c3p0.minPoolSize}"/>
    <property name="autoCommitOnClose" value="${c3p0.autoCommitOnClose}"/>
    <property name="checkoutTimeout" value="${c3p0.checkoutTimeout}"/>
    <property name="acquireRetryAttempts" value="${c3p0.acquireRetryAttempts}"/>
</bean>

<!-- 配置SqlSessionFactory对象 -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <!-- 注入数据库连接池 -->
    <property name="dataSource" ref="dataSource"/>
    <!-- 扫描entity包 使用别名 -->
    <property name="typeAliasesPackage" value="cn.wmyskxz.entity"/>
    <!-- 扫描sql配置文件:mapper需要的xml文件 -->
    <property name="mapperLocations" value="classpath:mapper/*.xml"/>
</bean>

<!-- 配置扫描Dao接口包，动态实现Dao接口，注入到spring容器中 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <!-- 注入sqlSessionFactory -->
    <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    <!-- 给出需要扫描Dao接口包 -->
    <property name="basePackage" value="cn.wmyskxz.dao"/>
</bean>

<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!-- 注入数据库连接池 -->
    <property name="dataSource" ref="dataSource"/>
</bean>

<!-- 配置基于注解的声明式事务 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

在【spring-mvc.xml】中完成 Spring MVC 的相关配置：

<!-- 扫描web相关的bean -->
<context:component-scan base-package="cn.wmyskxz.controller"/>

<!-- 开启SpringMVC注解模式 -->
<mvc:annotation-driven/>

<!-- 静态资源默认servlet配置 -->
<mvc:default-servlet-handler/>

<!-- 配置jsp 显示ViewResolver -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
    <property name="prefix" value="/WEB-INF/views/"/>
    <property name="suffix" value=".jsp"/>
</bean>

在【jdbc.properties】中配置 c3p0 数据库连接池：

jdbc.driver=com.mysql.jdbc.Driver

数据库地址

jdbc.url=jdbc:mysql://localhost:3306/ssm?useUnicode=true&characterEncoding=utf8

用户名

jdbc.username=root

密码

jdbc.password=root

最大连接数

c3p0.maxPoolSize=30

最小连接数

c3p0.minPoolSize=10

关闭连接后不自动commit

c3p0.autoCommitOnClose=false

获取连接超时时间

c3p0.checkoutTimeout=10000

当获取连接失败重试次数

c3p0.acquireRetryAttempts=2
在【logback.xml】中完成日志输出的相关配置：

%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n

以上就完成了基本的相关配置：

添加进了 SSM 项目所需要的 jar 包
配置好了 spring/mybatis/spring MVC 的相关配置信息（自动扫描 cn.wmyskxz 包下的带有注解的类）
通过 xml 配置的方式配置好了日志和数据库
第四步：测试 SSM 框架
准备好用来测试的数据库：

DROP DATABASE IF EXISTS ssm;
CREATE DATABASE ssmDEFAULT CHARACTER SET utf8;

use ssm;
CREATE TABLE user(
id int(11) NOT NULL AUTO_INCREMENT,
username varchar(50) NOT NULL,
PRIMARY KEY (id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

INSERT INTO user VALUES(1,‘我没有三颗心脏‘);
接下来在【cn.wmyskxz.entity】包下创建好对应的实体类 User ：

package cn.wmyskxz.entity;

/**

User 实体类
@author: @我没有三颗心脏
@create: 2018-04-23-上午 9:23
*/
public class User {

private int id;
private String username;

/* getter and setter */
}
在【cn.wmyskxz.dao】包下创建好 Dao 接口：

package cn.wmyskxz.dao;

import cn.wmyskxz.entity.User;

public interface UserDao {

// 根据 id 寻找对应的 User
User findUserById(int id);

}
在【resources/mapper】下编写 UserDao.xml 映射文件：

<select id="findUserById" resultType="cn.wmyskxz.entity.User" parameterType="int">
    SELECT * FROM user WHERE id = #{id}
</select>

在编写好每一个 Dao 的时候，我们都需要对它进行测试，在【test/java】下创建一个【UserDaoTest】的测试类：

import cn.wmyskxz.dao.UserDao;
import cn.wmyskxz.entity.User;
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;

/**

UserDao 的测试类
@author: @我没有三颗心脏
@create: 2018-04-23-上午 9:54
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:spring-mybatis.xml"})
public class UserDaoTest {

@Autowired
private UserDao userDao;

@Test
public void testFindUserById() {
int id = 1;
User user = userDao.findUserById(id);
System.out.println(user.getId() + ":" + user.getUsername());
}
}
运行测试代码，能够获取到正确的信息：

接着在【cn.wmyskxz.service】包下编写好对应的 UserService 接口：

package cn.wmyskxz.service;

import cn.wmyskxz.entity.User;

public interface UserService {

// 根据 id 寻找对应的 User
public User findUserById(int id);

}
和对应的实现类：

package cn.wmyskxz.service;

import cn.wmyskxz.dao.UserDao;
import cn.wmyskxz.entity.User;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**

UserService 对应的实现类
@author: @我没有三颗心脏
@create: 2018-04-23-上午 9:31
*/

@Service("userService")
public class UserServiceImpl implements UserService {

@Resource
private UserDao userDao;

public User findUserById(int id) {
    return userDao.findUserById(id);
}

}
在【cn.wmyskxz.controller】下创建【UserController】控制类：

package cn.wmyskxz.controller;

import cn.wmyskxz.entity.User;
import cn.wmyskxz.service.UserService;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.annotation.Resource;

/**

User 的控制类
@author: @我没有三颗心脏
@create: 2018-04-23-上午 9:58
*/
@Controller
@RequestMapping("")
public class UserController {

@Resource
private UserService userService;

@RequestMapping("/findUser")
public String findUser(Model model) {
int id = 1;
User user = this.userService.findUserById(id);
model.addAttribute("user", user);
return "index";
}
}
最后在【WEB-INF/views】下创建 index.jsp 用于接收并显示数据：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>

SSM 框架整合

${user.id}：${user.username}

配置好 Tomcat 服务器，运行并在浏览器中输入：localhost/findUser

即完成了 SSM 的整合！

参考资料：使用idea2017搭建SSM框架
最开始想要手动添加 jar 包依赖创建，但是调了 1 天的 bug 也不通，换了很多 jar 包...有点崩溃，后来直接使用 Maven 创建就成功了...参考了上面链接的文章。

SSM 框架架构图
为了更加能理解 SSM 处理用户请求的整个过程，下面给出一张 SSM 系统架构图：

通常我们还会在 Controller 和 Service 层中引入工厂模式，这里仅仅是创建了一个简单的 SSM 项目，用以测试而已，并且没有配置 MyBatis 的相关信息，如果需要配置在 resource 目录下创建一个 SqlMapConfig.xml 文件并且完成的相关配置即可。

参考资料：
《Java EE 互联网轻量级框架整合开发》
《Spring MVC + MyBatis开发从入门到项目实战》
全能的百度和万能的大脑

学生管理系统（SSM简易版）总结

之前用 Servlet + JSP 实现了一个简易版的学生管理系统，在学习了 SSM 框架之后，我们来对之前写过的项目重构一下！

技术准备
为了完成这个项目，需要掌握如下技术：

Java
基础知识
前端：
HTML, CSS, JAVASCRIPT, JQUERY
J2EE：
Tomcat, Servlet, JSP, Filter
框架：
Spring, Spring MVC, MyBatis, Spring 与 MyBatis 整合, SSM 整合
数据库：
MySQL
开发工具：
IDEA, Maven
开发流程
之前虽然已经使用 Servlet + JSP 完成了简单的开发，这次使用 SSM 仅仅是重构工作，但我们仍然按照商业项目的开发步骤来一步一步完成，进一步熟悉这个过程，重复的部分我就直接复制了。

① 需求分析
首先要确定要做哪些功能

使用数据库来保存数据
能增删改查学生的信息（学号，名称，年龄，性别，出生日期）
② 表结构设计
根据需求，那么只需要一个 student 表就能够完成功能了。

创建数据库：student
将数据库编码格式设置为 UTF-8 ，便于存取中文数据

DROP DATABASE IF EXISTS student;
CREATE DATABASE student DEFAULT CHARACTER SET utf8;
创建学生表：student
不用学生学号(studentID)作为主键的原因是：不方便操作，例如在更新数据的时候，同时也要更改学号，那这样的操作怎么办呢？
所以我们加了一个 id 用来唯一表示当前数据。

CREATE TABLE student(
id int(11) NOT NULL AUTO_INCREMENT,
student_id int(11) NOT NULL UNIQUE,
name varchar(255) NOT NULL,
age int(11) NOT NULL,
sex varchar(255) NOT NULL,
birthday date DEFAULT NULL,
PRIMARY KEY (id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
MySQL 在 Windows 下不区分大小写，但在 Linux 下默认区分大小写，因此，数据库名、表明、字段名都不允许出现任何大写字母，避免节外生枝。

③ 原型设计
就是设计界面，在商业项目中，这是很重要的一步，我们可以解除界面原型，低成本、高效率的与客户达成需求的一致性。

这个项目一共就分为两个页面：

主页面：
首页

学生编辑页面：
编辑页面

④ SSM 环境搭建
在真正开始编写代码之前，我们首先需要先来搭建好我们的 SSM 环境。

第一步：创建 Maven webapp 项目
首先新建工程，选择 Maven 标签，然后勾选上【Create from archetype】选择 webapp：

点击下一步，填写上【GroupId】和【ArtifactId】：

GroupId：项目组织唯一的标识符，实际对应 JAVA 的包的结构，也就是 main 目录下 java 的目录结构（包）
AritifactId：项目的唯一标识符，实际对应项目的名称，就是项目根目录的名称
实际上你可以乱填上试试，我就不乱填了
然后是确认项目路径，这一步你可以看到 Maven 配置中的参数，不需要做改动，直接下一步就可以（图中的路径是我配置的本地 Maven 仓库的地址）：

确认项目名称和路径，点击【Finish】即可：

等待一会儿，控制台就会有创建成功的提示信息，我们把【Enable Auto-Import】点上，这个提示会在每次 pom.xml 有改动时出现，自动导入，省掉麻烦：

第二步：搭建项目目录结构
下面就是 Maven 风格的 webapp 的默认目录结构：

注意： webapp 是默认没有 java 源文件也没有 test 目录的。
遵循 Maven 的统一项目结构，我们搭建出项目的完整目录结构如下图：

我们并没有使用 Log4j 来输出日志，而是使用 logback
提示：我们可以在 IDEA 中右键目录然后选择【Make Directory as】，让 IDEA 识别不同的目录作用

这里的目录建好之后还需要设置一下，让 IDEA 识别目录作用，选择【File】>【Project Structure】：

设置好之后点击 OK，即完成了项目目录的搭建。

第三步：配置文件内容
在【pom.xml】文件中声明依赖的 jar 包：

<modelVersion>4.0.0</modelVersion>
<packaging>war</packaging>

<name>StudentManagerSSM</name>
<groupId>cn.wmyskxz</groupId>
<artifactId>StudentManagerSSM</artifactId>
<version>1.0-SNAPSHOT</version>

<build>
    <plugins>
        <plugin>
            <groupId>org.mortbay.jetty</groupId>
            <artifactId>maven-jetty-plugin</artifactId>
            <version>6.1.7</version>
            <configuration>
                <connectors>
                    <connector implementation="org.mortbay.jetty.nio.SelectChannelConnector">
                        <port>8888</port>
                        <maxIdleTime>30000</maxIdleTime>
                    </connector>
                </connectors>
                <webAppSourceDirectory>${project.build.directory}/${pom.artifactId}-${pom.version}
                </webAppSourceDirectory>
                <contextPath>/</contextPath>
            </configuration>
        </plugin>
    </plugins>
</build>

<properties>
    <!-- 设置项目编码编码 -->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <!-- spring版本号 -->
    <spring.version>4.3.5.RELEASE</spring.version>
    <!-- mybatis版本号 -->
    <mybatis.version>3.4.1</mybatis.version>
</properties>

<dependencies>

    <!-- jstl标签 -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>
    <dependency>
        <groupId>org.apache.taglibs</groupId>
        <artifactId>taglibs-standard-impl</artifactId>
        <version>1.2.5</version>
    </dependency>


    <!-- java ee -->
    <dependency>
        <groupId>javax</groupId>
        <artifactId>javaee-api</artifactId>
        <version>7.0</version>
    </dependency>

    <!-- 单元测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>

    <!-- 实现slf4j接口并整合 -->
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.2</version>
    </dependency>

    <!-- JSON -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.8.7</version>
    </dependency>


    <!-- 数据库 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.41</version>
        <scope>runtime</scope>
    </dependency>

    <!-- 数据库连接池 -->
    <dependency>
        <groupId>com.mchange</groupId>
        <artifactId>c3p0</artifactId>
        <version>0.9.5.2</version>
    </dependency>

    <!-- MyBatis -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>${mybatis.version}</version>
    </dependency>

    <!-- mybatis/spring整合包 -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>1.3.1</version>
    </dependency>

    <!-- Spring -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</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-context</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>
    <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-test</artifactId>
        <version>${spring.version}</version>
    </dependency>

</dependencies>

标签是默认生成的
我们在中声明了编码格式以及使用的 spring 和 mybatis 的版本号，然后在中声明了具体的 jar 包
在【web.xml】中声明编码过滤器并配置 DispatcherServlet ：

<!-- 编码过滤器 -->
<filter>
    <filter-name>encodingFilter</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>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

<!-- 配置DispatcherServlet -->
<servlet>
    <servlet-name>SpringMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 配置springMVC需要加载的配置文件-->
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-*.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
    <async-supported>true</async-supported>
</servlet>
<servlet-mapping>
    <servlet-name>SpringMVC</servlet-name>
    <!-- 匹配所有请求 -->
    <url-pattern>/</url-pattern>
</servlet-mapping>

在【spring-mybatis.xml】中完成 spring 和 mybatis 的配置：

<!-- 扫描service包下所有使用注解的类型 -->
<context:component-scan base-package="cn.wmyskxz.service"/>

<!-- 配置数据库相关参数properties的属性：${url} -->
<context:property-placeholder location="classpath:jdbc.properties"/>

<!-- 数据库连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="${jdbc.driver}"/>
    <property name="jdbcUrl" value="${jdbc.url}"/>
    <property name="user" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
    <property name="maxPoolSize" value="${c3p0.maxPoolSize}"/>
    <property name="minPoolSize" value="${c3p0.minPoolSize}"/>
    <property name="autoCommitOnClose" value="${c3p0.autoCommitOnClose}"/>
    <property name="checkoutTimeout" value="${c3p0.checkoutTimeout}"/>
    <property name="acquireRetryAttempts" value="${c3p0.acquireRetryAttempts}"/>
</bean>

<!-- 配置SqlSessionFactory对象 -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <!-- 注入数据库连接池 -->
    <property name="dataSource" ref="dataSource"/>
    <!-- 扫描entity包 使用别名 -->
    <property name="typeAliasesPackage" value="cn.wmyskxz.entity"/>
    <!-- 扫描sql配置文件:mapper需要的xml文件 -->
    <property name="mapperLocations" value="classpath:mapper/*.xml"/>
</bean>

<!-- 配置扫描Dao接口包，动态实现Dao接口，注入到spring容器中 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <!-- 注入sqlSessionFactory -->
    <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    <!-- 给出需要扫描Dao接口包 -->
    <property name="basePackage" value="cn.wmyskxz.dao"/>
</bean>

<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!-- 注入数据库连接池 -->
    <property name="dataSource" ref="dataSource"/>
</bean>

<!-- 配置基于注解的声明式事务 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

在【spring-mvc.xml】中完成 Spring MVC 的相关配置：

<!-- 扫描web相关的bean -->
<context:component-scan base-package="cn.wmyskxz.controller"/>

<!-- 开启SpringMVC注解模式 -->
<mvc:annotation-driven/>

<!-- 静态资源默认servlet配置 -->
<mvc:default-servlet-handler/>

<!-- 配置jsp 显示ViewResolver -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
    <property name="prefix" value="/WEB-INF/views/"/>
    <property name="suffix" value=".jsp"/>
</bean>

在【jdbc.properties】中配置 c3p0 数据库连接池：

jdbc.driver=com.mysql.jdbc.Driver

数据库地址

jdbc.url=jdbc:mysql://localhost:3306/student?useUnicode=true&characterEncoding=utf8

用户名

jdbc.username=root

密码

jdbc.password=root

最大连接数

c3p0.maxPoolSize=30

最小连接数

c3p0.minPoolSize=10

关闭连接后不自动commit

c3p0.autoCommitOnClose=false

获取连接超时时间

c3p0.checkoutTimeout=10000

当获取连接失败重试次数

c3p0.acquireRetryAttempts=2
在【logback.xml】中完成日志输出的相关配置：

%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n

以上就完成了 SSM 框架的基本配置：

添加进了 SSM 项目所需要的 jar 包
配置好了 spring/mybatis/spring MVC 的相关配置信息（自动扫描 cn.wmyskxz 包下的带有注解的类）
通过 xml 配置的方式配置好了日志和数据库
⑤ 实体类设计
实体类仅仅是对数据库中表的一一映射（表中字段名应该和实体类中的名称一一对应），同时可能还需要兼顾对业务能力的支持。

在 Packge【cn.wmyskxz.entity】下创建 Student 类：

package cn.wmyskxz.entity;
import java.util.Date;

/**

Student 实体类
@author: @我没有三颗心脏
@create: 2018-04-23-下午 13:34
*/
public class Student {

private int id;
private int student_id;
private String name;
private int age;
private String sex;
private Date birthday;

/* getter and setter */
}

⑤ DAO 类的设计
DAO，即 Date Access Object，数据库访问对象，就是对数据库相关操作的封装，让其他地方看不到 JDBC 的代码。

在【cn.wmyskxz.dao】包下创建【StudentDao】接口：

package cn.wmyskxz.dao;

import cn.wmyskxz.entity.Student;

import java.util.List;

public interface StudentDao {
int getTotal();
void addStudent(Student student);
void deleteStudent(int id);
void updateStudent(Student student);
Student getStudent(int id);
List list(int start, int count);
}
然后在【resources/mapper】下创建好对应的映射文件【StudengDao.xml】：

<!-- 查询数据条目 -->
<select id="getTotal" resultType="int">
    SELECT COUNT(*) FROM student
</select>

<!-- 增加一条数据 -->
<insert id="addStudent" parameterType="Student">
    INSERT INTO student VALUES(NULL, #{student_id}, #{name}, #{age}, #{sex}, #{birthday})
</insert>

<!-- 删除一条数据 -->
<delete id="deleteStudent" parameterType="int">
    DELETE FROM student WHERE id = #{id}
</delete>

<!-- 更新一条数据 -->
<update id="updateStudent" parameterType="Student">
    UPDATE student SET student_id = #{student_id}, name = #{name},
    age = #{age}, sex = #{sex}, birthday = #{birthday} WHERE id = #{id}
</update>

<!-- 查询一条数据 -->
<select id="getStudent" resultMap="student" parameterType="int">
    SELECT * FROM student WHERE id = #{id}
</select>

<resultMap id="student" type="student">
    <id column="id" property="id"/>
    <result column="student_id" property="student_id"/>
    <result column="name" property="name"/>
    <result column="age" property="age"/>
    <result column="sex" property="sex"/>
    <result column="birthday" property="birthday"/>
</resultMap>

<!-- 查询从start位置开始的count条数据-->
<select id="list" resultMap="student">
    SELECT * FROM student ORDER BY student_id desc limit #{param1}, #{param2}
</select>

编写好了 Dao 类是需要测试的，这里测试类就不给出了。

⑦ 业务类设计
问题：为什么不直接使用 Dao 类而是还要在上面封装一层 Service 层呢？
回答：
基于责任分离的原则，Dao 层就应该专注于对数据库的操作，而在 Service 层我们可以增加一些非 CRUD 的方法去更好的完成本身抽离出来的 service 服务（业务处理）。
在【cn.wmyskxz.service】包下创建【StudentService】接口：

package cn.wmyskxz.service;

import cn.wmyskxz.entity.Student;

import java.util.List;

public interface StudentService {

/**
 * 获取到 Student 的总数
 * @return
 */
int getTotal();

/**
 * 增加一条数据
 * @param student
 */
void addStudent(Student student);

/**
 * 删除一条数据
 * @param id
 */
void deleteStudent(int id);

/**
 * 更新一条数据
 * @param student
 */
void updateStudent(Student student);

/**
 * 找到一条数据
 * @param id
 * @return
 */
Student getStudent(int id);

/**
 * 列举出从 start 位置开始的 count 条数据
 * @param start
 * @param count
 * @return
 */
List<Student> list(int start, int count);

}
并在相同包名下创建实现类【StudentServiceImpl】：

package cn.wmyskxz.service;

import cn.wmyskxz.dao.StudentDao;
import cn.wmyskxz.entity.Student;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**

StudentService 的实现类
@author: @我没有三颗心脏
@create: 2018-04-23-下午 13:51
*/
@Service
public class StudentServiceImpl implements StudentService {

@Autowired
StudentDao studentDao;

public int getTotal() {
return studentDao.getTotal();
}

public void addStudent(Student student) {
studentDao.addStudent(student);
}

public void deleteStudent(int id) {
studentDao.deleteStudent(id);
}

public void updateStudent(Student student) {
studentDao.updateStudent(student);
}

public Student getStudent(int id) {
return studentDao.getStudent(id);
}

public List list(int start, int count) {
return studentDao.list(start, count);
}
}
⑧ 功能开发
在【cn.wmyskxz.controller】包下创建【StudentController】控制器，代码基本上都是复制黏贴之前在 Servlet 中的代码：

package cn.wmyskxz.controller;

import cn.wmyskxz.entity.Student;
import cn.wmyskxz.service.StudentService;
import cn.wmyskxz.util.Page;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

/**

Student 控制器
@author: @我没有三颗心脏

@create: 2018-04-23-下午 13:27
*/
@Controller
@RequestMapping("")
public class StudentController {

@Autowired
private StudentService studentService;

@RequestMapping("/addStudent")
public String addStudent(HttpServletRequest request, HttpServletResponse response) {

Student student = new Student();

int studentID = Integer.parseInt(request.getParameter("student_id"));
String name = request.getParameter("name");
int age = Integer.parseInt(request.getParameter("age"));
String sex = request.getParameter("sex");
Date birthday = null;
// String 类型按照 yyyy-MM-dd 的格式转换为 java.util.Date 类
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
try {
    birthday = simpleDateFormat.parse(request.getParameter("birthday"));
} catch (ParseException e) {
    e.printStackTrace();
}

student.setStudent_id(studentID);
student.setName(name);
student.setAge(age);
student.setSex(sex);
student.setBirthday(birthday);

studentService.addStudent(student);

return "redirect:listStudent";

}

@RequestMapping("/listStudent")
public String listStudent(HttpServletRequest request, HttpServletResponse response) {

// 获取分页参数
int start = 0;
int count = 10;

try {
    start = Integer.parseInt(request.getParameter("page.start"));
    count = Integer.parseInt(request.getParameter("page.count"));
} catch (Exception e) {
}

Page page = new Page(start, count);

List<Student> students = studentService.list(page.getStart(), page.getCount());
int total = studentService.getTotal();
page.setTotal(total);

request.setAttribute("students", students);
request.setAttribute("page", page);

return "listStudent";

}

@RequestMapping("/deleteStudent")
public String deleteStudent(int id) {
studentService.deleteStudent(id);
return "redirect:listStudent";
}

@RequestMapping("/editStudent")
public ModelAndView editStudent(int id) {
ModelAndView mav = new ModelAndView("editStudent");
Student student = studentService.getStudent(id);
mav.addObject("student", student);
return mav;
}

@RequestMapping("/updateStudent")
public String updateStudent(HttpServletRequest request, HttpServletResponse response) {

Student student = new Student();

int id = Integer.parseInt(request.getParameter("id"));
int student_id = Integer.parseInt(request.getParameter("student_id"));
String name = request.getParameter("name");
int age = Integer.parseInt(request.getParameter("age"));
String sex = request.getParameter("sex");

SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
Date birthday = null;
try {
    birthday = simpleDateFormat.parse(request.getParameter("birthday"));
} catch (ParseException e) {
    e.printStackTrace();
}

student.setId(id);
student.setStudent_id(student_id);
student.setName(name);
student.setAge(age);
student.setSex(sex);
student.setBirthday(birthday);

studentService.updateStudent(student);
return "redirect:listStudent";

}
}
注意：所有的学号都用 student_id 表示，为了契合在数据库中的字段名（包括下面的 JSP 文件）
JSP 文件也直接黏之前的就好了，不过需要注意所有的 name 属性：

【listStudent.jsp】：

<%@ page contentType="text/html;charset=UTF-8" language="java"
pageEncoding="UTF-8" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

<%-- 引入JQ和Bootstrap --%> 学生管理页面 - 首页

学生列表 - 共${page.total}人
学号	姓名	年龄	性别	出生日期	编辑	删除
${s.student_id}	${s.name}	${s.age}	${s.sex}	${s.birthday}

增加学生

【editStudent.jsp】：

<%@ page contentType="text/html;charset=UTF-8" language="java"
pageEncoding="UTF-8" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<%-- 引入JQ和Bootstrap --%> 学生管理页面 - 编辑页面

编辑学生

style.css 文件：
body {
padding-top: 60px;
}

div.listDIV {
width: 600px;
margin: 0 auto;
}

div.editDIV {
width: 400px;
margin: 0 auto;
}

nav.pageDIV {
text-align: center;
}

div.addDIV {
width: 300px;
margin: 0 auto;
}

table.addTable {
width: 100%;
padding: 5px;
}

table.addTable td {
padding: 5px;
}

table.editTable {
width: 100%;
padding: 5px;
}

table.editTable td {
padding: 5px;
}
项目的整体结构

分页功能
首先在 Packge【util】包下创建一个 Page 工具类：
package cn.wmyskxz.util;

public class Page {

int start;      // 开始数据
int count;      // 每一页的数量
int total;      // 总共的数据量

public Page(int start, int count) {
    super();
    this.start = start;
    this.count = count;
}

public boolean isHasPreviouse(){
    if(start==0)
        return false;
    return true;

}
public boolean isHasNext(){
    if(start==getLast())
        return false;
    return true;
}

public int getTotalPage(){
    int totalPage;
    // 假设总数是50，是能够被5整除的，那么就有10页
    if (0 == total % count)
        totalPage = total /count;
        // 假设总数是51，不能够被5整除的，那么就有11页
    else
        totalPage = total / count + 1;

    if(0==totalPage)
        totalPage = 1;
    return totalPage;

}

public int getLast(){
    int last;
    // 假设总数是50，是能够被5整除的，那么最后一页的开始就是40
    if (0 == total % count)
        last = total - count;
        // 假设总数是51，不能够被5整除的，那么最后一页的开始就是50
    else
        last = total - total % count;

    last = last<0?0:last;
    return last;
}

// 各种 setter 和 getter

}
totalPage 是计算得来的数，用来表示页码一共的数量
在首页显示的 StudentList 用 page 的参数来获取：

List students = studentService.list(page.getStart(), page.getCount());
并且在映射文件中用 LIMIT 关键字：

第一个参数为 start，第二个参数为 count
这样就能根据分页的信息来获取到响应的数据

编写分页栏：

1.写好头和尾

2.写好? ?这两个功能按钮
使用标签来增加边界判断，如果没有前面的页码了则设置为disable状态

    <li <c:if test="${!page.hasPreviouse}">class="disabled"</c:if>>
        <a href="?page.start=0">
            <span>?</span>
        </a>
    </li>

    <li <c:if test="${!page.hasPreviouse}">class="disabled"</c:if>>
        <a href="?page.start=${page.start-page.count}">
            <span>?</span>
        </a>
    </li>

再通过 JavaScrip 代码来完成禁用功能：

3.完成中间页码的编写
从 0 循环到 page.totalPage - 1 ，varStatus 相当于是循环变量

status.count 是从1开始遍历
status.index 是从0开始遍历
要求：显示当前页码的前两个和后两个就可，例如当前页码为3的时候，就显示 1 2 3(当前页) 4 5 的页码
理解测试条件：
-10 <= 当前页*每一页显示的数目 - 当前页开始的数据编号 <= 30

只要理解了这个判断条件，其他的就都好理解了

<c:if test="${status.count*page.count-page.start<=30 && status.count*page.count-page.start>=-10}">
    <li <c:if test="${status.index*page.count==page.start}">class="disabled"</c:if>>
        <a
                href="?page.start=${status.index*page.count}"
                <c:if test="${status.index*page.count==page.start}">class="current"</c:if>
        >${status.count}</a>
    </li>
</c:if>

4.在控制器中获取参数

// 获取分页参数
int start = 0;
int count = 10;

try {
start = Integer.parseInt(request.getParameter("page.start"));
count = Integer.parseInt(request.getParameter("page.count"));
} catch (Exception e) {
}

....

// 共享 page 数据
request.setAttribute("page", page);
Date 转换的问题
最开始的时候，我们看到页面上显示的日期是这样的格式：

这显然是我们不希望看到的

解决方案：在映射文件中设置日期显示的类型。

重新部署文件，然后刷新页面，就能看到我们希望的效果啦：

项目总结
由于之前的项目代码都有，所以在重构的时候，基本上没有花什么时间就完成了项目的搭建，能够体会到代码分离的重要性，这在很大程度上保证了我们的代码复用。
相较于之前用 Servlet + JSP 来完成，很明显的感觉是DAO层的编写方便了很多，仅仅需要编写一个 xml 映射文件和一个 Dao 层接口就可以完成功能，而不用自己再去重复的去在每一个 CRUD 方法中去处理结果集，重复而且繁琐。
注解真的很方便，这不仅仅提升了我们自身开发的效率，写起来也很带劲儿。
开发效率快，而且低耦合，我们基于 xml 配置了大部分的工作，在基于 SSM 框架开发时，我们可以把专注点集中在逻辑处理上。
在 SSM 框架中能方便的对项目进行修改，这不仅仅得益于框架的约定，使得代码分离并且可复用，也得益于 Maven 工具对于项目的管理。
我们能够通过一个 Controller 来完成五个 Servlet 的功能，并且通过注解来完成配置。
项目改进
项目很简单，仅仅也只是在数据库增删改查的基础上增加了一个界面，我们来动手改一改。

改进一：增加删除提示
第一个想到的就是删除提示，没有删除提示是很要命的一件事情，如果手滑了一下那可能就悲剧了....

首先我们在顶部的标签中的中增加一段代码：

function del() {
var msg = "您真的确定要删除吗？\n\n请确认！";
if (confirm(msg) == true) {
return true;
} else {
return false;
}
}
然后在删除 a 标签页中增加 onclick 属性：

onclick="javascript:return del();"
....就像下面这样....
td>
当我们刷新页面后，点击删除就会弹出提示信息：

改进二：编辑页面自动勾选上性别
在当前的项目中，如果点击编辑按钮进入到编辑页面后，性别这个选项是空选的状态，这就很low：

这个也很简单，在 editStudent 页面增加一些判断就好了：

用标签来判断 sex 的值，然后根据对应的属性增加 checked 属性，这样就可以自动勾选上所对应的属性：

改进三：空值判断
我们允许设置为 null 的值仅仅为出生日期，其他的值均不允许出现空值，所以我们需要加入空值判断：

function checkEmpty(id, name) {
var value = $("#" + id).val();
if (value.length == 0) {
alert(name + "不能为空");
$("#" + id).focus();
return false;
}
return true;
}
然后再为 form 创建一个 id 属性值为 “addForm” 并添加进判断空值的方法：

注意：这里需要写在 $(function(){}) 里面，等待文档加载完毕才能生效。
这里并没有为 sex 属性判断空值，我们采用一个简单的为 sex 添加一个默认勾选项来省略空值的判断。
同样的，我们也在编辑页面，采用同样的方法进行空值判断：

当进入编辑页面的时候已经有默认的勾选项了，所以 sex 值仍然不需要判空
最后给出项目地址：https://github.com/wmyskxz/StudentManager-SSM
欢迎转载，转载请注明出处！
@我没有三颗心脏
CSDN博客：http://blog.csdn.net/qq939419061
简书：http://www.jianshu.com/u/a40d61a49221

Spring SSM 框架

标签：云计算参考 slf4j column 高效数据库的操作 hub The war

原文地址：https://www.cnblogs.com/Leo_wl/p/8969817.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行

学号：
姓名：
年龄：
性别：	男女
出生日期：

学号：
姓名：
年龄：
性别：	男女
出生日期：