示例:
实现用户通过页面输入用户名密码
登陆成功跳转欢迎页面,并且更新下用户信息,记录日志
失败返回原来的页面让用户重新输入
需要两个表,一个用户表,一个日志表
两个页面,一个登录页面,带两个input, 一个是欢迎页面
这就是例子的背景,很简单的
--------------------------
使用的工具是java8 tomcat7 spring版本的eclipse,mysql5.6,navicat
不知道如何上传附件,上传到资源的地方了,加一个链接在此
http://download.csdn.net/detail/noteless/9404168
--------------------------
1.创建数据库
navicat在localhost里面新建数据库
名字:sprinEg 编码utf-8
注意:字段名字使用navicat的时候不要有空格,否则会直接报错的
建立用户表
CREATE TABLE `t_user` (
`user_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '用户Id',
`user_name` varchar(30) NOT NULL COMMENT '用户名',
`credits` int(11) DEFAULT NULL COMMENT '积分',
`password` varchar(32) DEFAULT NULL COMMENT '密码',
`last_visit` datetime DEFAULT NULL COMMENT '最后访问时间',
`last_ip` varchar(23) DEFAULT NULL COMMENT '最后访问ip',
PRIMARY KEY (`user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
建立登录日志
CREATE TABLE `t_login_log` (
`login_log_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '登录日志Id',
`user_id` int(11) DEFAULT NULL COMMENT '用户ID',
`ip` varchar(23) DEFAULT NULL COMMENT '登录Ip',
`login_dateTime` datetime DEFAULT NULL COMMENT '登录时间',
PRIMARY KEY (`login_log_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
手动插入一条数据 用户名/密码 admin/123456 其他随手填上
2,创建项目
包结构
所需要的jar包直接拷贝到lib目录下
然后选定 build path
之后开始写项目代码
配置文件
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"
xmlns:p="http://www.springframework.org/schema/p"
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.2.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd">
<!--扫描类包,标注spring注解的类自动转换成bean,同时完成bean的注入 (这样类中定义的spring注解 比如@repository @autowired等才能起作用) -->
<context:component-scan base-package="com.bbs.dao" />
<!--扫描service包,应用spring注解配置 -->
<context:component-scan base-package="com.bbs.service" />
<!--配置事务管理器 -->
<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.bbs.service..*(..))" />
<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>
<!-- 定义一个使用DBCP实现的数据源 -->
<bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource"
destroy-method="close"
p:driverClassName="com.mysql.jdbc.Driver"
p:url="jdbc:mysql://localhost:3306/sampledb"
p:username="root"
p:password="123456"/>
<!--定义jdbc模板bean -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"
p:dataSource-ref="dataSource"/>
</beans>
两个实体
User.java
package com.bbs.domain;
import java.io.Serializable;
import java.util.Date;
public class User implements Serializable{
/**
*
*/
private static final long serialVersionUID = 1L;
private int userId;
private String userName;
private String password;
private int credits;
private String lastIp;
private Date lastVisit;
public int getUserId() {
return userId;
}
public void setUserId(int userId) {
this.userId = userId;
}
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;
}
public int getCredits() {
return credits;
}
public void setCredits(int credits) {
this.credits = credits;
}
public String getLastIp() {
return lastIp;
}
public void setLastIp(String lastIp) {
this.lastIp = lastIp;
}
public Date getLastVisit() {
return lastVisit;
}
public void setLastVisit(Date lastVisit) {
this.lastVisit = lastVisit;
}
}
LoginLog.java
package com.bbs.domain;
import java.io.Serializable;
import java.util.Date;
public class LoginLog implements Serializable{
/**
*
*/
private static final long serialVersionUID = 1L;
private int loginLogId;
private int userId;
private String ip;
private Date loginDate;
public int getLoginLogId() {
return loginLogId;
}
public void setLoginLogId(int loginLogId) {
this.loginLogId = loginLogId;
}
public int getUserId() {
return userId;
}
public void setUserId(int userId) {
this.userId = userId;
}
public String getIp() {
return ip;
}
public void setIp(String ip) {
this.ip = ip;
}
public Date getLoginDate() {
return loginDate;
}
public void setLoginDate(Date loginDate) {
this.loginDate = loginDate;
}
}
两个dao(用的jdbcTemplate)
LoginLogDao.java
package com.bbs.dao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import com.bbs.domain.LoginLog;
@Repository
public class LoginLogDao {
@Autowired
private JdbcTemplate jdbcTemplate;
public void insertLoginLog(LoginLog loginLog){
String sqlString ="INSERT INTO t_login_log(user_id,ip,login_datetime)"
+"VALUE(?,?,?)";
Object[] args={loginLog.getUserId(),loginLog.getIp(),loginLog.getLoginDate()};
jdbcTemplate.update(sqlString, args);
}
}
UserDao.java
package com.bbs.dao;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.omg.CORBA.PUBLIC_MEMBER;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowCallbackHandler;
import org.springframework.stereotype.Repository;
import com.bbs.domain.User;
@Repository
public class UserDao {
@Autowired
private JdbcTemplate jdbcTemplate;
public int getMatchCount(String userName,String password){
String sqlString="SELECT count(*) FROM t_user "
+"WHERE user_name=? and password=?";
return jdbcTemplate.queryForObject(sqlString,new Object[]{ userName,password}, java.lang.Integer.class);
}
public User findUserByUserName(final String userName){
String sqlString ="SELECT user_id,user_name,credits "
+"FROM t_user WHERE user_name=?";
final User user = new User();
jdbcTemplate.query(sqlString, new Object[]{userName},
new RowCallbackHandler() {
@Override
public void processRow(ResultSet rs) throws SQLException {
// TODO Auto-generated method stub
user.setUserId(rs.getInt("user_id"));
user.setUserName(userName);
user.setCredits(rs.getInt("credits"));
}
});
return user;
}
public void updateLoginInfo(User user){
String sqlString="UPDATE t_user SET last_visit=?,last_ip=?,credits=?"
+"WHERE user_id=?";
jdbcTemplate.update(sqlString,new Object[]{user.getLastVisit(),user.getLastIp(),user.getCredits(),user.getUserId()});
}
}
还有一个service
UserService.java
package com.bbs.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.bbs.dao.LoginLogDao;
import com.bbs.dao.UserDao;
import com.bbs.domain.LoginLog;
import com.bbs.domain.User;
@Service
public class UserService {
@Autowired
private UserDao userDao;
@Autowired
private LoginLogDao loginLogDao;
public boolean hasMatchUser(String userName,String password){
int matchCount = userDao.getMatchCount(userName, password);
return matchCount > 0 ;
}
public User findUserByUserName(String userName){
return userDao.findUserByUserName(userName);
}
public void loginSucess(User user){
user.setCredits(5+user.getCredits());
LoginLog loginLog = new LoginLog();
loginLog.setUserId(user.getUserId());
loginLog.setIp(user.getLastIp());
loginLog.setLoginDate(user.getLastVisit());
userDao.updateLoginInfo(user);
loginLogDao.insertLoginLog(loginLog);
}
}
至此后台代码完毕
增加一个测试函数
TestUserService.java
package test.bbs.service;
import static org.junit.Assert.*;
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;
import com.bbs.domain.User;
import com.bbs.service.UserService;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"/applicationContext.xml"})
public class TestUserService {
@Autowired
private UserService userService;
@Test
public void hasMAtchUser(){
boolean b1 = userService.hasMatchUser("admin", "123456");
boolean b2 = userService.hasMatchUser("admin", "11111");
assertTrue(b1);
//assertTrue(b2);
}
@Test
public void findUserByUserName(){
User user = userService.findUserByUserName("admin");
assertEquals(user.getUserName(),"admin");
}
}
运行测试,run as JUnit test
测试成功
3,整合mybatis
上面操作数据库用的是jdbctemplate,比较麻烦,我们整合一下mybatis
百度百科:
MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code,并且改名为MyBatis 。2013年11月迁移到Github。
iBATIS一词来源于“internet”和“abatis”的组合,是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects(DAO)
需要的jar
一个用来和spring无缝对接,一个是mybatis的核心包
首先需要增加配置文件
<!-- myBatis文件 -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<!-- 自动扫描映射文件 -->
<property name="mapperLocations">
<array>
<value>classpath:mapper/*.xml</value>
</array>
</property>
</bean>
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.bbs.dao.mapper" />
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
</bean>
这一段是固定格式的哈, dataSource是我们的数据源也就是连接数据库用的,之前设置过来的
使用mybatis一般我们需要两个文件,一个就是mapper映射接口,一个就是xml,里面写的sql
说白了就是mybaits把xml中的sql,处理后,可以通过mapper中的接口调用
注意,接口名字就是xml中的id
所以说到这也可以明白了,上面的自动扫描映射文件的xml就是我们写sql的地方
下面的就是mapper接口对应的包,它里面写的都是mapper接口
所以你要用的话,copy过去,修改一下这两个位置就好了
还有就是要知道,对照eclipse的话,创建项目后src就是这个classpath的哈
具体的请仔细学习mybaits
配置文件可以单独配置,也可以直接写道ApplicationContext,xml的,现在我们就是写在一起的
然后就是在项目里面把文件新建一下
新建一个包,com.bbs.dao.mapper 里面新建两个接口
src下面新建一个文件夹,mapper,里面新建两个配置文件
如下图所示
配置文件设置好了之后,文件也都创建好了
就是要写sql以及接口了
sql自然是要按照人家的规则来写了
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="com.bbs.dao.mapper.UserMapper">
<select id="getMatchCount" parameterType="com.bbs.domain.User"
resultType="java.lang.Integer">
SELECT count(*)
FROM
t_user
WHERE
user_name=#{userName}
and password=#{password}
</select>
<select id="findUserByUserName" parameterType="com.bbs.domain.User"
resultType="com.bbs.domain.User">
SELECT
t_user.user_id as userId,
t_user.user_name as userName,
t_user.credits as credits,
t_user.password as password,
t_user.last_ip as lastIp,
t_user.last_visit as lastVisit
FROM
t_user
WHERE
user_name=#{userName}
</select>
<update id="updateLoginInfo" parameterType="com.bbs.domain.User">
UPDATE t_user
<set>
<if test="lastVisit !=null">
last_visit = #{lastVisit},
</if>
<if test="lastIp !=null and lastIp !=''">
last_ip = #{lastIp},
</if>
<if test="credits !=null and credits !=''">
credits = #{credits},
</if>
</set>
where user_id=#{userId}
</update>
<insert id="insertUser" parameterType="com.bbs.domain.User">
insert into t_user(
user_name,
credits,
password,
last_ip,
last_visit
)
values(
#{userName},
#{credits},
#{password},
#{lastIp},
#{lastVisit}
)
</insert>
<update id="updateUserInfo" parameterType="com.bbs.domain.User">
UPDATE t_user
<set>
<if test="lastVisit !=null">
last_visit = #{lastVisit},
</if>
<if test="lastIp !=null and lastIp !=''">
last_ip = #{lastIp},
</if>
<if test="credits !=null and credits !=''">
credits = #{credits},
</if>
</set>
where user_id=#{userId}
</update>
</mapper>
LoginLogMapper.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="com.bbs.dao.mapper.LoginLogMapper">
<insert id="insertLoginLog" parameterType="com.bbs.domain.LoginLog">
insert into t_login_log(
user_id,
ip,
login_datetime
)
values(
#{userId},
#{ip},
#{loginDate}
)
</insert>
</mapper>
说到这,说点常见的问题
1,数据库中的字段名字和java代码中的名字,要注意,如果不一样记得select的时候要as一下为代码中的,不然人家怎么知道如何映射
2,insert,update的时候,前面的是数据库的,后面的是java代码的
3.使用if判断入参条件的时候要小心
比如此处的lastVisit是数据库中datetime格式的,java代码中是Date(util)类型的,使用if的时候这个lastvisit就不能跟下面lastIp似得有一个什么and lastIp!='',因为是一个时间对象嘛,比较的时候当做字符串了,你要是用了就会报错,
org.mybatis.spring.MyBatisSystemException: nested exception is org.apache.ibatis.exceptions.PersistenceException:
### Error updating database. Cause: java.lang.IllegalArgumentException: invalid comparison: java.util.Date and java.lang.String
..........
就是sql嘛,注释也都没写,毕竟是简单的例子
接着是跟xml映射的接口
UserMapper.java
package com.bbs.dao.mapper;
import com.bbs.domain.User;
public interface UserMapper {
public Integer getMatchCount(User user);
public User findUserByUserName(User user);
public void updateLoginInfo(User user);
public void insertUser(User user);
public void updateUserInfo(User user);
}
LoginLogMapper.java
package com.bbs.dao.mapper;
import com.bbs.domain.LoginLog;
public interface LoginLogMapper {
public void insertLoginLog(LoginLog loginLog);
}
这样子就可以通过mapper接口执行sql了
之前的时候我们的接口写的不怎么规范,我们现在规范一下
把原来的userService.java拆分下
拆解成
UserService.java
LoginLogService.java
这两个接口
实际使用的时候,使用他们的实现类
面向接口的编程嘛,好处自行百度
UserService.java
package com.bbs.service;
import com.bbs.domain.User;
public interface UserService {
public Boolean hasMatchUser(User user);
public User findUserByUserName(User user);
public void loginSucess(User user);
public void insertUser(User user);
public void UpdateUser(User user);
}
UserServiceImpl.java
package com.bbs.service;
import java.util.Date;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.bbs.dao.mapper.UserMapper;
import com.bbs.domain.LoginLog;
import com.bbs.domain.User;
@Service
public class UserServiceImpl implements UserService {
@Autowired
private UserMapper userMapper;
@Autowired
private LoginLogService loginLogService;
@Override
public Boolean hasMatchUser(User user) {
Integer matchCount = userMapper.getMatchCount(user);
if(matchCount > 0){
return true;
}else{
return false;
}
}
@Override
public User findUserByUserName(User user) {
return userMapper.findUserByUserName(user);
}
@Override
public void loginSucess(User user) {
user.setCredits(5+user.getCredits());
user.setLastVisit(new Date());
LoginLog loginLog = new LoginLog();
loginLog.setUserId(user.getUserId());
loginLog.setIp(user.getLastIp());
loginLog.setLoginDate(new Date());
userMapper.updateLoginInfo(user);
loginLogService.insertLoginLog(loginLog);
}
@Override
public void insertUser(User user) {
userMapper.insertUser(user);
}
@Override
public void UpdateUser(User user) {
userMapper.updateUserInfo(user);
}
}
LoginLogService.java
package com.bbs.service;
import com.bbs.domain.LoginLog;
public interface LoginLogService {
public void insertLoginLog(LoginLog loginLog);
}
LoginLogServiceImpl.java
package com.bbs.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.bbs.dao.mapper.LoginLogMapper;
import com.bbs.domain.LoginLog;
@Service
public class LoginLogServiceImpl implements LoginLogService {
@Autowired
private LoginLogMapper loginLogMapper;
@Override
public void insertLoginLog(LoginLog loginLog) {
loginLogMapper.insertLoginLog(loginLog);
}
}
这样子接口和他的实现类都写好了
要注意到,@service 和@Autowired哈
那么到现在为止,项目的逻辑就是这样子的了
spring+mybaits
配置文件中配置了数据库等信息,配置了需要自动扫描的一些包,要扫描包中的注解嘛,重要的还整合了mybatis
通过mybatis来操作数据库,mapper来直接调用
改造成了面向接口的编程
通过userService和LoginLogService来调用,实际上执行的还是实现类嘛
实现类通过组合调用mapper提供的接口,来操作数据库,来操作数据
项目的改造完成了
测试也要修改一下了..
package test.bbs.service;
import static org.junit.Assert.*;
import java.util.Date;
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;
import com.bbs.domain.User;
import com.bbs.service.UserService;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"/applicationContext.xml"})
public class TestUserService {
@Autowired
private UserService userService;
@Test
public void hasMAtchUser(){
User user1 = new User();
User user2 = new User();
user1.setUserName("admin");
user1.setPassword("123456");
user2.setUserName("admin");
user2.setPassword("11111");
boolean b1 = userService.hasMatchUser(user1);
//boolean b2 = userService.hasMatchUser(user2);
assertTrue(b1);
//assertTrue(b2);
}
@Test
public void findUserByUserName(){
User user = new User();
user.setUserName("admin");
User user1 = userService.findUserByUserName(user);
System.out.println(user1.getUserName());
assertEquals(user1.getUserName(),"admin");
}
@Test
public void loginSucess(){
User user = new User();
user.setUserName("admin");
user= userService.findUserByUserName(user);
userService.loginSucess(user);
}
@Test
public void insertUser(){
User user = new User();
user.setUserName("user1");
user.setPassword("123456");
user.setCredits(0);
user.setLastIp("255.255.255.255");
user.setLastVisit(new Date(0) );
userService.insertUser(user);
}
@Test
public void updateUserInfo(){
User user = new User();
user.setUserId(2);
user.setLastVisit(new Date() );
user.setCredits(5+user.getCredits());
userService.UpdateUser(user);
}
}
目测都执行成功了哈
以上就是spring+mybatis的一个基本项目(后台)
4,配置下日志log4j
log4j
就是log for java嘛,老外都喜欢这样子,比如那个I18n ---internationalization 不就是i和n之间有18个字母...
http://logging.apache.org/log4j/2.x/
直接入正题
他是一个强大的日止功能组件
想要用他,根把大象放到冰箱里面一样多
1,下载一个jar包,放到项目中去
2,搞一个配置文件(可以吧之前用过的直接拷贝进去修改一下即可)
说简单的话,很简单,但是说起来配置,其实还是蛮多的,毕竟功能强大
现在我的配置文件
### set log levels ###
log4j.rootLogger = DEBUG,stdout
### 输出到控制台 ###
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = [%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n
### sql ###
log4j.logger.java.sql.Connection=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
看一个测试用例的使用
我们之前的TestUserService.java
就干了三件事儿
1,import
2,定义变量
3,使用
运行这个用例
我们看一下输出
注意注意:
Logger.debug ( Object message ) ;
Logger.info ( Object message ) ;
Logger.warn ( Object message ) ;
Logger.error ( Object message ) ;
<strong>他有好几个方法哈</strong>
说到这里其实,你可以把我这一段,直接复制粘贴过去,如果有需要比如修改文件日志保存路径,稍作修改即可,下面的具体说配置文件的可以不看的....
src同级创建并设置log4j.properties
#####下面的才是正文,这句话以及这句话以上请不要复制#####
### 设置###
log4j.rootLogger = debug,stdout,D,E
### 输出信息到控制抬 ###
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = [%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n
### 输出DEBUG 级别以上的日志到=E://logs/error.log ###
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File = E://logs/log.log
log4j.appender.D.Append = true
log4j.appender.D.Threshold = DEBUG
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %m%n
### 输出ERROR 级别以上的日志到=E://logs/error.log ###
log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
log4j.appender.E.File =E://logs/error.log
log4j.appender.E.Append = true
log4j.appender.E.Threshold = ERROR
log4j.appender.E.layout = org.apache.log4j.PatternLayout
log4j.appender.E.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] - [ %p ] %m%n
比如我们加上这么一段
它的效果就是这样子的
5,springMvc
之前所有做到的,完成了后台,业务层和持久层的开发完成了
接下来就是展现层了
有很多的mvc框架,这里我们用springMVC
首先还是需要jar包
我们既然是web项目了
也是不可少的,所以需要增加这两个包
我们需要配置web.xml
一个web项目,启动的时候,容器这里指的是tomcat这种,会首先读取web.xml配置文件里面的配置
所以他是最根本的配置文件
spring的配置需要在这里设置下,我们用的tomcat容器就可以自动启动我们的spring容器了
<?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">
<!-- 1,从类路径下加载spring的配置文件,classpath关键字特指类路径下加载 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param>
<!--2,负责启动spring容器的监听器,它将引用1处的上下文参数,获得spring配置文件的地址 -->
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
</web-app>
1. 首先是我们通过web.xml的上下文参数,指定配置文件的路径
2. 然后就是指定Spring所提供的ContextLoaderListener的web容器监听器
该监听器在web容器启动的时候自动启动,根据1 处的参数的值,获取配置文件路径,读取配置文件,并且启动spring
还需要配置servlet截获URL请求
<servlet>
<servlet-name>bbs</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,还需要有一个配置文件,这个配置文件
默认为WEB-INF目录下,名称为[<servlet-name>]-servlet.xml
下面这个,就是指定了配置文件的名字和位置
说白了就是,配置了servlet需要有一个对照的配置文件,要么按照人家默认规范的位置和名字写一个
要么就自己规定一个名字和位置
建议自定义一个
我们还要定义拦截的请求不是么
<servlet-mapping>
<servlet-name>bbs</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
这个就是了,名字自然就是我们的servlet名字,匹配的就是.do结尾的,按道理来说,你设置成啥都是可以的
所以我们的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">
<!-- 1,从类路径下加载spring的配置文件,classpath关键字特指类路径下加载 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param>
<!--2,负责启动spring容器的监听器,它将引用1处的上下文参数,获得spring配置文件的地址 -->
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<servlet>
<servlet-name>bbs</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>bbs</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
</web-app>
springmvc.xml内容为
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:mvc="http://www.springframework.org/schema/mvc"
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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.2.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd">
<!-- 自动扫描带有@Controller注解的控制层,注入为bean -->
<context:component-scan base-package="com.bbs.web" />
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/views/" />
<property name="suffix" value=".jsp" />
</bean>
</beans>
配置好了之后,我们该开始写controller了
先写一个测试用的最基本的
在我们之前的web目录下面,我们新建一个class,名字为,LoginController
package com.bbs.web;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import com.bbs.service.UserService;
@Controller
public class LoginController {
@Autowired
private UserService userService;
@RequestMapping(value="/login")
public String toLoginPage(){
return "login";
}
}
@controller是controller的注解哈
我们返回一个视图
视图的名字是login
还记得么,我们在servlet的配置文件中,本项目中就是springmvc.xml中,配置了,页面文件的
位置
前缀后缀哦
然后我们需要按照我们自己指定的位置,创建一个jsp文件,命名为login.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>标题</title>
</head>
<body>
这个是首页
</body>
</html>
如上我们就写了一行代码作为测试
至此,我们的整个的过程就搭建好了,运行一下
eclipse配置下tomcat,项目添加进去(右键 new server 创建一个server选择你电脑上安装好的tomcat即可)
http://localhost:8080/bbs/login.do
页面经过配置的servlet拦截,走到controller,controller帮我们找到页面
成功走通了
http://localhost:8080/bbs/login.do
8080这个是server的配置,看准端口哈,如果是修改成80的话,就不用写了可以省略
bbs是我们的项目的名字
login是我们的controller中的配置
do是配置文件中的后缀
最终完善
至此已经基本测试成功了,我们稍作完善,让它成为一个更加完整的项目
我们现在重新规划下逻辑
两个页面
一个登录页面
一个欢迎页面
登陆页面输入账号密码,登陆成功的话,跳转登陆成功 欢迎页面
并且,更新用户登录信息以及记录登录日志
login.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>标题</title>
</head>
<body>
${Info}
请输入用户名,密码登陆:
<form action="/bbs/checkLogin.do" meathod="post">
用户名:
<input type="text" name="userName">
<br>
密码:
<input type="password" name="password">
<br>
<input type="submit" value="登陆">
<input type="reset" value="重置">
</form>
</body>
</html>
如果使用一些c标签需要<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
并且要引入jstl jar包
welcome.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>标题</title>
</head>
<body>
登陆成功!
<br>
欢迎光临!
</body>
</html>
controller
package com.bbs.web;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import com.bbs.domain.User;
import com.bbs.service.UserService;
@Controller
public class LoginController {
@Autowired
private UserService userService;
@RequestMapping(value="/login")
public String toLoginPage(HttpServletRequest request){
return "login";
}
@RequestMapping(value="/checkLogin")
public String loginPage(HttpServletRequest request,User user){
Boolean loginSucess = userService.hasMatchUser(user);
if(loginSucess){
userService.loginSucess(userService.findUserByUserName(user));
request.getSession().setAttribute("Info","");
return "welcome";
}else{
request.getSession().setAttribute("Info","请重新输入!!");
return "redirect:/login.do";
}
}
}
打开login展示登录页面
表单提交到checklogin
校验成功,执行登陆成功操作
失败重定向到登录页面
注意此处的
request.getSession().setAttribute("Info","请重新输入!!");
是放到session中的,如果只是request.setAttribute是不行的,页面读取不到
因为重定向了
相当于重新一个request,放进去的值就变化了
顺便记一下,这几个区别
session 一次会话
request 一次请求
就像两个人对话,request只有在你说一句话的时候,就有一个,别人说话,或者你说下一句话,就换了
对话 就是你们来来回回的说,他都是同一个
比如提交一个表单就是一个请求,打开一个超链接也是一个请求,当请求结束这个request也就消亡了
当用户第一次和服务器建立连接时,服务器就会产生一个session直到用户离开或超时,比如关闭浏览器session也会销毁
或者说,你存储在request中的,在当次请求中都是存在的,如果你redirect就不行了
但是,session,你页面怎么跳转,他都还在的
他们都可以存很多东西,能放得东西也没啥区别,区别主要在于声明周期
直接在web contain中进行对象的实例化。
内置对象 | 类型 | 作用域 |
pageContext | javax.servlet.jsp.pageContext | page |
request | javax.servlet.http.HttpServletRequest | request |
response | javax.servlet.http.HttpServletResponse | page |
session | javax.servlet.http.HttpSession | session |
application | javax.servlet.ServletContext | application |
config | javax.servlet.ServletConfig | page |
out | java.servlet.jsp.JspWriter | page |
page | java.lang.Object | page |
exception | java.lang.Throwable | page
|
顾名思义,内置对象就是本来就有的意思,直接可以使用
设置属性:public void setAttribute(String name,Object.value)
取得属性:public void getAttribute(String name)
看表格可以看出来,他们的作用域可以区分为四种
在一个页面范围内:page
在一次服务器请求范围内:request
在一次会话范围内:session
在一个应用服务器范围内:application
Session对象主要用于保存用户的各种信息,直到它的生命周期超过或被人为释放掉为止,可以通过session对象来判断此用户是否是合法用户。
Session对象是javax.Servlet.http.HttpSession接口的实例化对象,session属于http协议范畴之内的对象,所以只有唯一http包下有此接口,没有任何继承关系,用户只要一连接到服务器,则立刻分配一个session给用户。
啰嗦了很多,一个简单的项目,已经完整的搭建好了