Maven Web App 新手demo------登陆界面

最新推荐文章于 2021-12-29 13:09:31 发布

Aaron - Wistron

最新推荐文章于 2021-12-29 13:09:31 发布

阅读量1.6k

点赞数

CC 4.0 BY-SA版权

分类专栏： Maven

本文链接：https://blog.youkuaiyun.com/Aaron121314/article/details/80157763

Maven 专栏收录该内容

2 篇文章

订阅专栏

本文详细介绍如何使用Spring框架在Eclipse中搭建一个具备用户登录和注册功能的基础系统。包括项目搭建步骤、数据库配置、代码实现等内容。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

【2018/9/8】我写了一篇新的，比较完善的，大家可以参考下。地址->

https://blog.youkuaiyun.com/Aaron121314/article/details/82453605

-----------------------------------------------------------------------------------------------------------------

这里只是写一个demo，走通流程，至于Maven等相关的知识不介绍。

程序就2功能，一个是注册用户，一个是登陆。

Eclipse已经包含了Maven，不要再去下载什么东西了。

一. 新建项目

1. 新建一个Maven项目

不要勾simple project

2. 选择web app

3. 填写Group Id等

4.修改JRE

当你创建完成项目后，会有错误。

所以要修改JRE

然后就会多了2个目录。

不要管错误，有错误也能运行。

二. 运行项目

1. 新建一个server

2. 选择Apache里面的Tomcat，版本根据你自己安装的的来选。

点击完Finish后，在eclipse中就会有这个项目了。

3. 运行项目

首先要确保你创建的项目是正确的，所以我们先不写代码，直接运行下。

右键你的项目，选择Run as->Run on Server->Finish

运行结果如下

三. 数据库

在开始写代码前，先把要用到的数据库准备好。这里我们的数据库叫sampledb，表名是t_user_aaron，里面只有2个内容，一个是name，一个是password，id的话是主键，也是自增的。

这里的数据库名要和下面的spring设置中的对应，否正不能连接数据库。

四. 代码

1. Pom.xml修改

打开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>com.aaron.demo</groupId>
  <artifactId>demo01</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>demo01 Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    
    		<!-- spring 依赖 -->
		<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-context-support</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-webmvc</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>commons-dbcp</groupId>
			<artifactId>commons-dbcp</artifactId>
			<version>${commons-dbcp.version}</version>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>${mysql.version}</version>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>servlet-api</artifactId>
			<version>${servlet.version}</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>${aspectj.version}</version>
		</dependency>


		<dependency>
			<groupId>org.testng</groupId>
			<artifactId>testng</artifactId>
			<version>${testng.version}</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>${spring.version}</version>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>3.8.1</version>
			<scope>test</scope>
		</dependency>
  </dependencies>
  <build>
    <finalName>demo01</finalName>
    		<plugins>

			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-surefire-plugin</artifactId>
				<version>2.17</version>
				<configuration>
					<parallel>methods</parallel>
					<threadCount>10</threadCount>
				</configuration>
			</plugin>
		</plugins>
  </build>
  	<properties>
		<file.encoding>UTF-8</file.encoding>
		<spring.version>4.2.2.RELEASE</spring.version>
		<mysql.version>5.1.6</mysql.version>
		<servlet.version>3.0-alpha-1</servlet.version>
		<aspectj.version>1.8.1</aspectj.version>
		<commons-codec.version>1.9</commons-codec.version>
		<commons-dbcp.version>1.4</commons-dbcp.version>
		<hibernate.validator.version>5.0.2.Final</hibernate.validator.version>
		<jetty.version>8.1.8.v20121106</jetty.version>
		<slf4j.version>1.7.5</slf4j.version>
		<testng.version>6.8.7</testng.version>
	</properties>
</project>

2. Spring相关配置

在src/main/resources下面新建一个aaron-context.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.0.xsd
       http://www.springframework.org/schema/context 
       http://www.springframework.org/schema/context/spring-context-4.0.xsd
       http://www.springframework.org/schema/tx 
       http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">
    
    <!-- 扫描类包，将标注Spring注解的类自动转化Bean，同时完成Bean的注入 -->
    <context:component-scan base-package="com.aaron.dao"/>
    <context:component-scan base-package="com.aaron.service"/>
    
    <!-- 配置数据源 -->
	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
		destroy-method="close" 
		p:driverClassName="com.mysql.jdbc.Driver"
		p:url="jdbc:mysql://localhost:3306/sampledb"
		p:username="root"
		p:password="cyh57791010" />

	<!-- 配置Jdbc模板  -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"
		p:dataSource-ref="dataSource" />
		
	<!-- 配置事务管理器 -->
	<bean id="transactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
		p:dataSource-ref="dataSource" />
		
	<!-- 通过AOP配置提供事务增强，让service包下所有Bean的所有方法拥有事务 -->
	<aop:config proxy-target-class="true">
		<aop:pointcut id="serviceMethod"
			expression="(execution(* com.aaron.service..*(..))) and (@annotation(org.springframework.transaction.annotation.Transactional))" />
		<aop:advisor pointcut-ref="serviceMethod" advice-ref="txAdvice" />
	</aop:config>
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="*" />
		</tx:attributes>
	</tx:advice>
</beans>

3. 持久层

在src/main/java下面新建一个包，com.aaron.domain 。然后在包下面新建一个User类。这个类可以看成是数据库的映射。

User类比较简单，就是用户名和密码。

User类代码：

package com.aaron.domain;

import java.io.Serializable;

public class User implements Serializable {
	
	private String userName;
	private String password;
	
	public String getUserName() {
		return userName;
	}
	
	public String getPassword() {
		return password;
	}
	
	public void setUserName(String userName) {
		this.userName=userName;
	}
	
	public void setPassword(String password) {
		this.password=password;
	}
}

在src/main/java下面新建一个包，com.aaron.dao。然后在包下面新建一个UserDao类。这个类是用来访问User的DAO（Data access object）。

UserDao包含2个方法。

getMatchCount(): 根据用户名和密码获取匹配用户数，等于1表示正确，等于0表示错误。

insertUser(): 插入一个新用户。

UserDao类代码：

package com.aaron.dao;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import com.aaron.domain.User;


@Repository
public class UserDao {
	
	private JdbcTemplate jdbcTemplate;
	
	private  final static String MATCH_COUNT_SQL = " SELECT count(*) FROM t_user_aaron  " +
			" WHERE name =? and password=? ";
	private final static String INSERT_USER_SQL= "INSERT INTO t_user_aaron(name,password) VALUES(?,?)";
	
	@Autowired
	public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
		this.jdbcTemplate=jdbcTemplate;
	}

	public int getMatchCount(String userName, String password) {

		return jdbcTemplate.queryForObject(MATCH_COUNT_SQL, new Object[]{userName, password}, Integer.class);
	}
	
	public int insertUser(User user) {
		Object[] args = { user.getUserName(),user.getPassword() };
		return jdbcTemplate.update(INSERT_USER_SQL, args);
		
	}
}

4. 业务层

在src/main/java下面新建一个包，com.aaron.service。然后在包下面新建一个UserService类。

UserService业务接口有2个业务方法，addUser()添加/注册一个用户，hasMatchUser()用于检测用户名和密码的正确性。

UserService类代码：

package com.aaron.service;

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

import com.aaron.dao.UserDao;
import com.aaron.domain.User;


@Service
public class UserService {

	private UserDao userDao;

	@Autowired
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}

	@Transactional
	public boolean addUser(User user) {
		int temp = userDao.insertUser(user);
		if (temp > 0) {
			return true;
		} else {
			return false;
		}
	}

	public boolean hasMatchUser(String userName, String password) {
		int matchCount = userDao.getMatchCount(userName, password);
		return matchCount > 0;
	}
}

5. 单元测试

到这里，基本的功能都已经完成（不包含界面，下面会介绍怎么添加界面），接下来就要对这个业务类做简单的测试。

在src/test/java/下面新建一个包，com.aaron.service，然后在里面新建一个测试类UserServiceTest，一定要以Test结尾。至于为什么，百度。

@ContextConfiguration("classpath*:/aaron-context.xml")就是之前配置的spring文件的名字。

这里就2个测试方法，addUser()测试添加用户，testHasMatchUser()测试是否有匹配用户。

UserServiceTest类代码：

package com.aaron.service;

import static org.testng.Assert.assertTrue;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.testng.AbstractTransactionalTestNGSpringContextTests;
import org.testng.annotations.Test;

import com.aaron.domain.User;

//Maven测试完后，为了保证数据库清洁，会把你对数据的操作回滚，所以如果你要测试的时候
//插入的数据还在，就要加这个。默认true
@Rollback(value = false)
@ContextConfiguration("classpath*:/aaron-context.xml")
public class UserServiceTest extends AbstractTransactionalTestNGSpringContextTests {

	@Autowired
	UserService userService;

	@Test
	public void addUser() {
		User user = new User();
		user.setUserName("aaron20");
		user.setPassword("123456");

		boolean b1 = userService.addUser(user);
		assertTrue(b1);
	}

	@Test
	public void testHasMatchUser() {
		boolean b1 = userService.hasMatchUser("aaron20", "123456");
		// boolean b2 = userService.hasMatchUser("admggin", "1111");
		assertTrue(b1);
		// assertTrue(b2);
	}
}

然后开始测试，右键项目，选择Run as->Maven test。第一次运行会让你写Maven的配置，之后你要改的话可以在Run as->Run configurations里面修改。Maven相关的编译参数自己百度。我们就简单的编译，配置如下：