我的Spring学习记录（五）

在我的Spring学习记录（四）中使用了注解的方式对前面三篇做了总结。而这次，使用了用户登录及注册来对于本人前面四篇做一个应用案例，希望通过这个来对于我们的Spring的使用有一定的了解。

1. 程序描述

首先，介绍一下这个程序具体是怎么走的。

我这里使用了画图软件简单的画了大概程序是怎么走的（有点难看，别介）

具体的描述就是，用户可以访问登录或者注册的页面，登录成功返回成功的页面，失败则反之。对于注册页面注册成功则为用户添加注册成功的奖励——10块钱（先别管这个合不合理），失败则返回失败页面。

2. 准备工作

这里添加了SpringMVC框架，但是，不会涉及到很多操作，只需要进行简单的配置。这里主要的是对于前面的Spring学习做一下总结

2.1. 添加pom.xml依赖

首先加入的是我的Spring学习记录（四）中使用的依赖。

	<properties>
        <spring.version>4.3.10.RELEASE</spring.version>
    </properties>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.31</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.44</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</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-aspects</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-test</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>RELEASE</version>
        </dependency>

    </dependencies>

然后，我们需要用到web框架，再次加入依赖

		<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>

2.2. 配置web.xml

我们是使用了tomcat来运行我们的程序的，所以，这里在tomcat启动的时候，需要告诉它，我们要做什么。因此，我们需要在web.xml中配置我们的SpringMVC的servlet以及配置tomcat启动时加载我们的Spring容器。以下是web.xml中的配置：

<web-app>
  <display-name>Archetype Created Web Application</display-name>

  <!--配置Spring配置信息-->
  <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框架的一个处理器，这能将所有的请求过滤，相当于我们struts2的StrutsPrepareAndExecuteFilter-->
  <!--与struts2不同的是这里使用servlet而它使用filter-->
  <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:spring-mvc.xml</param-value>
    </init-param>
    <!-- 配置springmvc什么时候启动，参数必须为整数 -->
    <!-- 如果为0或者大于0，则springMVC随着容器启动而启动 -->
    <!-- 如果小于0，则在第一次请求进来的时候启动 -->
    <load-on-startup>1</load-on-startup>
  </servlet>

  <servlet-mapping>
    <servlet-name>SpringMVC</servlet-name>
    <!--拦截所有的请求-->
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

2.3. 配置Spring各项信息

首先我们这里是有一个配置文件applicationContext.xml这是一个总的入口，因为我们平时的操作是将所有的信息整合到了一块，现在我们进行分开操作，将MVC中dao，service和视图层分别弄一个配置文件。

applicationContext.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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <!--加载db.properties配置文件-->
    <context:property-placeholder location="classpath:db.properties"/>

    <!--开启注解-->
    <context:annotation-config/>

    <import resource="applicationContext-dao.xml"/>
    <import resource="applicationContext-service.xml"/>

</beans>

applicationContext-dao.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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <!--配置DataSource-->
    <bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <!--以下是数据库连接的具体信息 通过表达式将db.properties的信息注入-->
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
    </bean>

    <context:component-scan base-package="cn.lger.dao"/>

</beans>

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

    <context:component-scan base-package="cn.lger.service"/>
    <!--开启aspect注解-->
    <aop:aspectj-autoproxy />
    <!--注册事务管理类-->
    <bean name="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--开启事务注解 注解添加事务管理类映射-->
    <tx:annotation-driven transaction-manager="transactionManager"/>

</beans>

spring-mvc.xml

因为SpringMVC现在不是重点，所以可以先不看重这个配置文件

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

    <!--配置视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--视图的后缀，配置后方便我们返回视图操作少写.jsp-->
        <property name="suffix" value=".jsp"/>
    </bean>

    <mvc:annotation-driven />
    <context:component-scan base-package="cn.lger.controller"/>

</beans>

是不是很奇怪为什么要这么做。因为我们实际的项目开发过程中，可能会遇到大量的配置信息。那么，如果所有的信息都堆积一块，这对于阅读性可能会造成不好的影响，现在，我们分开来配置，信息多了分开来看，这回增加可阅读性（但是也不是说这是最好的，因为，只有适合的）。

3. 代码实现

3.1. 数据库实现

这里我们的实体有用户名，密码和金钱数目，所以具体的SQL如下：

CREATE TABLE `user` (
  `id` int(11) NOT NULL auto_increment,
  `username` varchar(255) NOT NULL,
  `password` varchar(255) NOT NULL,
  `money` float NOT NULL default '0',
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

这里是采用了MySQL数据库。因为是示例，所以请不必纠结设计合不合理。

3.2. 实体类

public class User {

    private Integer uId;
    private String username;
    private String password;
    private float money;

	//此处省略了getter、setter
}

3.3. dao 和 service

我们的dao因为方便的原因使用了JdbcTemplate，它不用我们写一些连接数据库等等的繁琐操作，简化了我们的操作步骤。而且这里需要注意的是：我们数据库操作需要使用数据源，所以我们要用构造函数去注入我们的DataSource

@Repository
public class UserDao extends JdbcTemplate {

    /**
     * 注入数据源dataSource
     * @param dataSource 数据源
     */
    @Autowired
    public UserDao(DataSource dataSource){
        super(dataSource);
    }

    /**
     * 根据用户名返回密码
     * @param username username
     * @return password
     */
    public String queryPasswordByUsername(final String username){
        SqlRowSet set = this.queryForRowSet("SELECT password FROM user WHERE username = ?", username);
        if (set.next()){
            return set.getString("password");
        }
        return null;
    }

    /**
     * 添加用户
     * @param user user
     * @return 添加成功返回>0 的数 失败0
     */
    public int addUser(User user){
        return this.update("INSERT INTO user(username, password) VALUES (?, ?)", user.getUsername(), user.getPassword());
    }

    /**
     * 添加用户的钱
     * @param money 钱的数目
     * @param username 用户名
     * @return 添加成功返回>0 的数 失败0
     */
    public int addMoney(final float money, final String username){
        return this.update("UPDATE user SET money = ? WHERE username = ?", money, username);
    }

}

在service中，我们登录的业务功能是用户注册成功后需要给用户10块钱，这是一个整体的操作，所以，我们这里需要用到事务操作，只需要在配置文件中配置好我们的事务管理类，然后加入@Transactional注解即可。

@Service
public class UserService {

    @Resource
    private UserDao userDao;

    public String queryPasswordByUsername(final String username){
        return userDao.queryPasswordByUsername(username);
    }

    /**
     * 注册用户
     * @param user user
     * @return 是否注册成功
     */
    @Transactional //事务操作
    public boolean regUser(User user){
        if (userDao.addUser(user) != 0){
            userDao.addMoney(10, user.getUsername());
            return true;
        }
        return false;
    }

}

上面中的注解@Service和@Repository是我们之前所用的@Component的变体，方便我们去区分。

如果说对于上面的各个配置文件和注解有不懂的可以看下之前的文章。

3.4. Controller的实现

这里的Controller也是Spring管理的Bean，这里需要引入新的注解@RequestMapping。这个注解是配置我们的地址映射的，比如：@RequestMapping(value = "/login", method = RequestMethod.GET)，这个的意思是当我们访问 http://..../login的时候就会调用应用该注解的对象或者是方法。

以下是我们注册和登录的Controller的具体实现：

@Controller
@RequestMapping(value = "/register")
public class RegisterController {

    @Resource
    private UserService userService;

    /**
     * 返回注册页面
     * @return register.jsp
     */
    @RequestMapping(method = RequestMethod.GET)
    public String regView(){
        return "register";
    }

    /**
     * 根据是否登录成功返回相应的页面
     * @param user user
     * @return 视图
     */
    @RequestMapping(method = RequestMethod.POST)
    public String reg(User user){
        if (userService.regUser(user))
            return "success";
        return "error";
    }
}

@Controller
@RequestMapping("/login")
public class LoginController {

    @Resource
    private UserService userService;

    /**
     * 返回登录页面
     * @return register.jsp
     */
    @RequestMapping(method = RequestMethod.GET)
    public String loginView(){
        return "login";
    }

    /**
     * 用户登录
     * @param user user
     * @return 返回视图（jsp）
     */
    @RequestMapping(method = RequestMethod.POST)
    public String login(User user){
        if (user.getPassword().equals(userService.queryPasswordByUsername(user.getUsername()))){
            return "success";
        }
        return "error";
    }

}

4. 加入视图

看到上面的Controller返回的success， error可能奇怪这是什么。其实我们在上面的spring-mvc.xml配置中有配置一个视图解析器，这里配置了<property name="suffix" value=".jsp"/>这是将Controller返回的视图后面加上后缀.jsp所以，success代表的是success.jsp。

因为没有把jsp放进我们的WEB-INF下面而是直接放入web根目录下所以没有加入前缀。

下面是我们的视图（jsp）：

login.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>login</title>
</head>
<body>
    <form action="/login" method="post">
        <input name="username" placeholder="username" type="text" required>
        <br>
        <input name="password" placeholder="username" type="password" required>
        <br>
        <input type="submit" value="submit">
    </form>
</body>
</html>

register.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>login</title>
</head>
<body>
    <form action="/register" method="post">
        <input name="username" placeholder="username" type="text" required>
        <br>
        <input name="password" placeholder="username" type="password" required>
        <br>
        <input type="submit" value="submit">
    </form>
</body>
</html>

error.jsp & success.jsp

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

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

5. 测试

首先，启动tomcat，然后，先注册账号，然后登录。

我们现在看看数据库的数据变化



现在，我们注册的用户有了，并且增加了10元。接下来我们登录账户，其结果是当我们敲入正确的用户名和密码后会返回success.jsp

6. 总结

现在我们基本上算是掌握了Spring的基础使用方法了，我觉得自己使用空闲写下这个就是希望当我有一段时间没有碰代码的时候能够看到这个快速的回忆，并且能够快速的使用。其实自己在学习的时候也有做一些笔记，但是，都很零散。所以，写博客可能会让我去整理下我那些零散的笔记吧。路漫漫，坚持应该是没错的。

以上的代码已上传GitHub