基于SSM框架的Web网站项目

我将手把手教大家完成一个基于SSM框架的web项目,实现注册、登录功能

注意:该项目需要的基础知识为Java/H5/CSS3/JS/JSON/AJAX/Servlet/JSP/SSM

一、 搭建开发环境(准备阶段)

  1. 安装JDK(JDK安装过程自行百度),目前我用的JDK版本是1.8
  2. 安装Eclipse(用MyEclipse也是可以的,或者IDEA),只要能装Tomcat插件即可
  3. 安装Tomcat 8.5,下载地址,顺便啰嗦一句,7.0以上版本就已经不需要配置环境变量了,当然你也可以为tomcat配置环境变量。
  4. 安装mysql数据库(我的数据库版本是5.5)

二、需求分析

这里我们的需求分析比较简单,我们想要做一个网站的注册登录功能,这时候我们就会去想数据库需要哪些表呢?表里需要哪些字段呢?这里我们设计的表略简单,目的就是为了方便新手入门理解。注册登录一个表足以,我们创建一个名为web的数据库,然后新建一个用户user表,表里面的字段和内容如下:

username password
xxxf 123456
xxxxf 123456
方大大 123456
测试员 123456

这里,我也给出创建数据库和表的SQL语句:

CREATE DATABASE web;
USE web;
CREATE TABLE USER(
username VARCHAR(20) NOT NULL PRIMARY KEY COMMENT '账号',
PASSWORD VARCHAR(20) NOT NULL COMMENT '密码'
)ENGINE=INNODB DEFAULT CHARSET=utf8;
INSERT INTO USER(username,PASSWORD) VALUES ('xxxf','123456');
INSERT INTO USER(username,PASSWORD) VALUES ('xxxxf','123456');
INSERT INTO USER(username,PASSWORD) VALUES ('方大大','123456');
INSERT INTO USER(username,PASSWORD) VALUES ('测试员','123456');

这里讲一下我们的业务逻辑,注册时会检查数据库有无此账号名,若有注册失败,若无则注册成功;登录时,检查数据库账号密码是否正确,账号或密码错误都会登录失败,并且前端会给返回提示。需求分析就这么多,还是蛮easy吧!

三、创建Web项目

  1. 打开Eclipse,选择File ->New->Dynamic Web Project ,新建名为PersonalWebSite的项目,一直选择next,最后把web.xml勾选上。
    这里写图片描述
    这里写图片描述
  2. 包结构
    这里写图片描述
    这里写图片描述
    这里简单解释一下src下每个包的作用:
    (1) POJO(Plain Ordinary Java Object)简单的Java对象,实际就是普通JavaBeans,是为了避免和EJB混淆所创造的简称。在POJO层我们创建的类,属性用private修饰,目的是为了封装属性,然后用getter&setter方法去获得或修改属性值。

    (2) DAO(Data Access Object)是一个数据访问接口,数据访问:顾名思义就是与数据库打交道。夹在业务逻辑与数据库资源中间。dao我们放了很多方法接口,在mapper层使用xml配置实现SQL语句的填充,这是使用mybatis的一贯做法。

    (3)Service层(biz):业务层 控制业务

    Service层主要负责业务模块的逻辑应用设计。和DAO层一样都是先设计接口,再创建要实现的类,然后在配置文件中进行配置其实现的关联。接下来就可以在service层调用接口进行业务逻辑应用的处理。
    封装Service层的业务逻辑有利于业务逻辑的独立性和重复利用性。

    (4)ServiceImpl:业务层的实现层
    service层只写了接口方法,并没有去真正去实现方法,在impl层我们会把具体实现方法写出来

    (5)Controller层: 控制层 控制业务逻辑

    Controller层负责具体的业务模块流程的控制,controller层主要调用Service层里面的接口控制具体的业务流程,控制的配置也需要在配置文件中进行。

    (6)config层:配置层
    一般来说,配置层在xml中实现也可,这里我用了java代码来实现SSM初始化配置,有三个类需要我们去关注,WebAPPInitialzer.java(配置类),RootConfig.java(Spring IoC上下文配置)、WebConfig.java(配置DispatchServlet上下文)

    (7)mybatis层:使用xml实现mybatis配置

四、SSM框架环境搭建

这里我使用的是全注解方式完成项目

首先我们需要做的是,把项目所需的jar包导入到你项目的WebContent/WEB-INF/lib或者是WebRoot/WEB-INF/lib下,这里我们的所依赖的JAR包有很多个,所以为了方便大家找到所需要的资源我将项目放到了github上,你只要访问我的Git仓库(戳这里),在WebContent/WEB-INF/lib下复制所有的jar包到你本地代码同样的目录下,再buildpath一下就可以使用啦!顺便提一下,这里面有很多jar包该项目并没有用到,为什么不删除呢?答案是:我比较懒,不想花时间去挑选JAR包。如果你用maven去构建项目,只需要在pom.xml把所需要的jar包信息配置上也可以达到相同的效果。

1.通过继承AbstractAnnotationConfigDispatcherServletInitializer(这个类名字巨长,反正我是记不住)去配置其他内容,因此首先来配置WebAPPInitialzer,如代码所示:

package com.xxxxf.config;

import javax.servlet.MultipartConfigElement;
import javax.servlet.ServletRegistration.Dynamic;

import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

/**
 *WebAPPInitialzer.java配置类
 */

public class WebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {

    // Spring IoC环境配置
    @Override
    protected Class<?>[] getRootConfigClasses() {
        // 配置Spring IoC资源
        return new Class<?>[] { RootConfig.class };
    }

    // DispatcherServlet环境配置
    @Override
    protected Class<?>[] getServletConfigClasses() {
        // 加载Java配置类
        return new Class<?>[] { WebConfig.class };
    }

    // DispatchServlet拦截请求配置
    @Override
    protected String[] getServletMappings() {
        return new String[] { "*.do" };//拦截所有以.do结尾的请求
    }

    /**
     * @param dynamic
     *            Servlet上传文件配置.
     */
    @Override
    protected void customizeRegistration(Dynamic dynamic) {
        // 配置上传文件路径
        String filepath = "e:/mvc/uploads";
        // 5MB
        Long singleMax = (long) (5 * Math.pow(2, 20));
        // 10MB
        Long totalMax = (long) (10 * Math.pow(2, 20));
        // 设置上传文件配置
        dynamic.setMultipartConfig(new MultipartConfigElement(filepath, singleMax, totalMax, 0));
    }

}

2.上面代码重写的三个方法就可以配置Web工程中的Spring IoC资源和DispatchServlet的配置内容,然后是配置Spring IoC容器,配置类RootConfig,代码如下:

package com.xxxxf.config;

import java.util.Properties;

import javax.sql.DataSource;

import org.apache.commons.dbcp.BasicDataSourceFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.annotation.TransactionManagementConfigurer;

import redis.clients.jedis.JedisPoolConfig;

@Configuration
//定义Spring 扫描的包
@ComponentScan(value= "com.*", 
includeFilters= {@Filter(type = FilterType.ANNOTATION, value ={Service.class})})
//使用事务驱动管理器
@EnableTransactionManagement
//实现接口TransactionManagementConfigurer,这样可以配置注解驱动事务
public class RootConfig implements TransactionManagementConfigurer {

    private DataSource dataSource = null;

    /**
     * 配置数据库.
     * @return 数据连接池
     */
    @Bean(name = "dataSource")
    public DataSource initDataSource() {
        if (dataSource != null) {
            return dataSource;
        }
        Properties props = new Properties();
        props.setProperty("driverClassName", "com.mysql.jdbc.Driver");
        props.setProperty("url", "jdbc:mysql://localhost:3306/web?useUnicode=true&characterEncoding=UTF-8");
        props.setProperty("username", "root");
        props.setProperty("password", "123456");
        props.setProperty("maxActive", "200");
        props.setProperty("maxIdle", "20");
        props.setProperty("maxWait", "30000");
        try {
            dataSource = BasicDataSourceFactory.createDataSource(props);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("连接成功----------");
        return dataSource;
    }

    /***
     * 配置SqlSessionFactoryBean
     * @return SqlSessionFactoryBean
     */
    @Bean(name="sqlSessionFactory")
    public SqlSessionFactoryBean initSqlSessionFactory() {
        SqlSessionFactoryBean sqlSessionFactory = new SqlSessionFactoryBean();
        sqlSessionFactory.setDataSource(initDataSource());
        //配置MyBatis配置文件
        Resource resource = new ClassPathResource("mybatis/mybatis-config.xml");
        sqlSessionFactory.setConfigLocation(resource);
        return sqlSessionFactory;
    }

    /***
     * 通过自动扫描,发现MyBatis Mapper接口
     * @return Mapper扫描器
     */
    @Bean 
    public MapperScannerConfigurer initMapperScannerConfigurer() {
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.*");
        msc.setSqlSessionFactoryBeanName("sqlSessionFactory");
        msc.setAnnotationClass(Repository.class);
        return msc;
    }


    /**
     * 实现接口方法,注册注解事务,当@Transactional 使用的时候产生数据库事务 
     */
    @Override
    @Bean(name="annotationDrivenTransactionManager")
    public PlatformTransactionManager annotationDrivenTransactionManager() {
        DataSourceTransactionManager transactionManager = 
           new DataSourceTransactionManager();
        transactionManager.setDataSource(initDataSource());
        return transactionManager;
    }


}

3.有了Spring IoC容器后,还需要配置DispatchServlet上下文,完成这个任务的便是WebConfig这个类,代码如下:

package com.xxxxf.config;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Executor;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.http.MediaType;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.scheduling.annotation.AsyncConfigurerSupport;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Controller;
import org.springframework.web.servlet.HandlerAdapter;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

@Configuration
//定义Spring MVC扫描的包
@ComponentScan(value="com.*",
includeFilters= {@Filter(type = FilterType.ANNOTATION, value = Controller.class)})
//启动Spring MVC配置
@EnableWebMvc
public class WebConfig extends AsyncConfigurerSupport { 

    /***
     * 通过注解 @Bean 初始化视图解析器
     * @return ViewResolver 视图解析器
     */
    @Bean(name="internalResourceViewResolver")
    public ViewResolver initViewResolver() {
        InternalResourceViewResolver viewResolver =new InternalResourceViewResolver();
        viewResolver.setPrefix("/WEB-INF/jsp/");
        viewResolver.setSuffix(".jsp");
        return viewResolver;
    }

    /**
     * 初始化RequestMappingHandlerAdapter,并加载Http的Json转换器
     * @return  RequestMappingHandlerAdapter 对象
     */
    @Bean(name="requestMappingHandlerAdapter") 
    public HandlerAdapter initRequestMappingHandlerAdapter() {
        //创建RequestMappingHandlerAdapter适配器
        RequestMappingHandlerAdapter rmhd = new RequestMappingHandlerAdapter();
        //HTTP JSON转换器
        MappingJackson2HttpMessageConverter  jsonConverter 
            = new MappingJackson2HttpMessageConverter();
        //MappingJackson2HttpMessageConverter接收JSON类型消息的转换
        MediaType mediaType = MediaType.APPLICATION_JSON_UTF8;
        List<MediaType> mediaTypes = new ArrayList<MediaType>();
        mediaTypes.add(mediaType);
        //加入转换器的支持类型
        jsonConverter.setSupportedMediaTypes(mediaTypes);
        //往适配器加入json转换器
        rmhd.getMessageConverters().add(jsonConverter);
        return rmhd;
    }

    /**
     * 异步任务处理
     * */
    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(5);
        taskExecutor.setMaxPoolSize(10);
        taskExecutor.setQueueCapacity(200);
        taskExecutor.initialize();
        return taskExecutor;
    }
}

4.通过上面三个类就搭建好了Spring MVC和Spring开发环境,但是没有对MyBatis进行配置,使用/mybatis/mabatis-config.xml进行配置,源码也很简单:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <mappers>
        <mapper resource="com/xxxxf/mapper/User.xml"/>
    </mappers>
</configuration>

到此我们的SSM环境也就搭建好了,现在就要去实现业务的代码了

五、实现需求代码

1.pojo层的User类,属性对应数据库表的每个字段,并且我们使用驼峰规则命名属性(这里很重要,字段userName和UserName在封装时差别很大,会映射不到mapper层的xml上),我们一贯的做法会让pojo序列化,这里虽然没有并发的情况,但是这是一种良好的做法。代码如下:

package com.xxxxf.pojo;

import java.io.Serializable;

/**
*@author xxxxf 
*2018年7月10日
*/
public class User implements Serializable{

    private static final long serialVersionUID = 89448952;
    private String userName;
    private String passWord;
    /**
     * getter && setter方法   
     */
    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;
    }
    /**
     * toString方法   
     */
    @Override
    public String toString() {
        return "user [userName=" + userName + ", passWord=" + passWord + "]";
    }



}

2.dao层中的UserDao类,这里实现我们业务和数据库直接交互的很多接口,@Repository的注解目的是持久化数据层。代码如下:

package com.xxxxf.dao;

import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;
import com.xxxxf.pojo.User;

/**
*@author xxxxf 
*2018年7月10日
*/
@Repository
public interface UserDao {
    /**
     * 查询用户信息   
     */
   public String getUser(@Param("userName") String userName,@Param("passWord") String passWord);
   /**
    * 增加用户  
    */
   public int addUser(User user);
   /**
    * 按主键查询用户   
    */
   public String getUserByUserName(String userName);
}

编写完dao层以后我们需要在mapper层编写User.xml实现DAO层接口方法,它相当于Dao的实现层(你可以这么理解,但是本质上有很大区别的),在User.xml我们是写了很多SQL语句与MySQL数据库进行交互,至于怎么去写SQL,举个例子:
select语句的返回值是不确定的,insert,update语句的返回值总是int(自己去思考是为什么?),所以Mybatis封装了这两种SQL语句的resultType,程序员就不用去写,这几种SQL语句参数类型也是根据方法里面的参数而决定的,两个或两个以上参数就需要用到@Param注解,MyBatis的语法我就不多赘述,有地方不理解或不清楚的自行百度,user.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.xxxxf.dao.UserDao">
    <!-- 查询用户信息 -->
    <select id="getUser" parameterType="map"
    resultType="string">
        select username as userName,password as passWord from 
        user where username=#{userName} and password=#{passWord}
    </select>
    <!--按主键查询  -->
    <select id="getUserByUserName" parameterType="string" resultType="string">
        select username as userName from user where username=#{userName}
    </select>
    <!--  public int addUser(User user); -->
    <!-- 增加用户信息 -->
    <insert id="addUser" parameterType="com.xxxxf.pojo.User" >
        insert into user(username,password) value(#{userName},#{passWord})
    </insert>
</mapper>

3.service层中的UserService类存放几个和用户相关的接口,这是是对用户而言的业务,这里有一种思想就是:用户要干嘛?我们程序员要去帮助用户实现什么接口?代码如下:

package com.xxxxf.service;

import com.xxxxf.pojo.User;

/**
*@author xxxxf 
*2018年7月10日
*/
public interface UserService {
  /**
   * 用户注册
   */
   public void  regist(User user);
   /**
    * 用户登录 
    */
   public String login(String userName,String passWord);
   /**
    * 检测用户是否存在
    */
   public String checkUser(String userName);
}

4.serviceImpl层中UserServiceImpl是UserService的实现类,@Service注解告诉Spring这是个业务层,UserService中只声明了几个接口,我们并没有去真正去实现,但是有人想为什么不直接写个实现类,反而要加一个Service层呢?这个问题,这要归结到代码复用性和维护性问题,如果你直接写一个实现,当你增加新的功能时就要在一大堆代码中是添加修改,这是非常耗时的操作,所以接口和实现分离有利于维护,代码如下:

package com.xxxxf.service.impl;

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

import com.xxxxf.dao.UserDao;
import com.xxxxf.pojo.User;
import com.xxxxf.service.UserService;

/**
*@author xxxxf 
*2018年7月10日
*/
@Service
public class UserServiceImpl implements UserService{
    //依赖注入
    @Autowired
    private UserDao userDao=null;

    @Override
    //读写提交
    @Transactional(isolation=Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
    public void regist(User user) {
        // TODO Auto-generated method stub
        userDao.addUser(user);

    }

    @Override
    //读写提交
    @Transactional(isolation=Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
    public String login(String userName, String passWord) {
        // TODO Auto-generated method stub
        //userDao.getUser(userName, passWord);
        return userDao.getUser(userName, passWord);
    }

    @Override
    //读写提交
    @Transactional(isolation=Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
    public String checkUser(String userName) {
        // TODO Auto-generated method stub
        return userDao.getUserByUserName(userName);
    }

}

5.控制层Controller
使用@Controller注解,然后使用@AutoWired导入service层,因为service中的方法是我们使用到的,controller通过接收前端传过来的参数进行业务操作,在返回一个指定的路径或者数据表。RequestMapping是一个用来处理请求地址映射的注解,可用于类或方法上。用于类上,表示类中的所有响应请求的方法都是以该地址作为父路径。@responseBody注解的作用是将controller的方法返回的对象通过适当的转换器转换为指定的格式之后,写入到response对象的body区,通常用来返回JSON数据或者是XML数据,需要注意的呢,在使用此注解之后不会再走试图处理器,而是直接将数据写入到输入流中,他的效果等同于通过response对象输出指定格式的数据。上面讲的这些都是Spring MVC知识,如果你看不懂请百度Spring MVC流程控制,基础知识我就不多废话。这里我们的控制器类叫UserController.java,里面有两个方法,一个叫注册,另一个叫登录,具体代码如下:

package com.xxxxf.controller;



import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.codehaus.jackson.map.util.JSONPObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.portlet.bind.annotation.ResourceMapping;
import org.springframework.web.servlet.ModelAndView;

import com.sun.java.swing.plaf.windows.resources.windows;
import com.xxxxf.dao.UserDao;
import com.xxxxf.pojo.User;
import com.xxxxf.service.UserService;

/**
*@author xxxxf 
*2018年7月10日
*/
@Controller
public class UserController {
    //依赖注入
    @Autowired
    private UserService userService=null;
    /**
     * 注册功能实现
     * */
    @RequestMapping(value="/register.do")
    @ResponseBody
    public ModelAndView regist(User user,Model model,HttpServletRequest request,HttpServletResponse response) throws IOException {
        request.setCharacterEncoding("utf-8");//必须写在第一位,因为采用这种方式去读取数据,否则数据会出错。
        //设置这样方式去读。这样中文就能够读取出来了,但是需要注意。表单的发送方式必须是method='post'
        response.setContentType("text/html;charset=utf-8");//设置传过去的页面显示的编码
        System.out.println("#################################################");
        System.out.println("用户注册:"+"账号:"+user.getUserName()+" "+"密码:"+user.getPassWord());
        String userName=user.getUserName();
        String result=userService.checkUser(userName);
            if (result==null) {
            userService.regist(user);
            PrintWriter out = response.getWriter();
            out.print("<script language=\"javascript\">alert('注册成功!前往登录页面');window.location.href='/PersonWebSite/login.jsp'</script>");
            //model.addAttribute("msg","注册成功");
            //return new ModelAndView("redirect:/login.jsp");
            }else {
                PrintWriter out = response.getWriter();
                out.print("<script language=\"javascript\">alert('注册失败!账号已存在!');window.location.href='/PersonWebSite/register.jsp'</script>");
                //model.addAttribute("msg","账号存在,请重新注册");
                //return new ModelAndView("redirect:/register.jsp");    
            }
            return null;

    }
    /**
     * 登录功能实现
     * */
    @RequestMapping(value="/login.do")
    @ResponseBody
    public  ModelAndView login( @RequestBody User user,HttpServletRequest request,HttpServletResponse response) {
        /*Model model,HttpServletRequest request,HttpServletResponse response*/
        System.out.println("***********************************");
        String username=user.getUserName();
        //request.getParameter(username);
        String password=user.getPassWord();
        System.out.println("用户登录:"+"账号:"+username+" "+"密码:"+password);
        String result=userService.login(username, password);
        System.out.println("从数据查询结果:"+result);//查询账号密码都正确,登录成功;账号或密码错误,result=null;
        if (result != null) {
            try {
                response.getWriter().write("true");
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }else {
            try {
                response.getWriter().write("false");
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        //model.addAttribute("msg", "登陆成功");
        return null;

    }
}

在Controller里面有一些业务流程控制,业务思想是需要你去仔细思考,比如:

        String userName=user.getUserName();
        String result=userService.checkUser(userName);
            if (result==null) {
            userService.regist(user);
            PrintWriter out = response.getWriter();
            out.print("<script language=\"javascript\">alert('注册成功!前往登录页面');window.location.href='/PersonWebSite/login.jsp'</script>");
            }else {
                PrintWriter out = response.getWriter();
                out.print("<script language=\"javascript\">alert('注册失败!账号已存在!');window.location.href='/PersonWebSite/register.jsp'</script>");
            }

这里为什么对result这个变量进行空判断,那你就得看看result是什么?奥,原来啊,reslut这个变量调用了checkUser(String userName)这个方法,这个方法去数据库查询是否有这个username是否存在,如果不存在就写进数据库里面,注册成功,如果有则前端就会提示注册失败。登录方法也用到了类似的思想,需要读者自己去揣摩思考。

至此我们的后台代码就告一段落了

六、前台代码

对于前端页面和功能的实现,我是借助于layui和jQuery这个前台框架,实际上我是个后台人员前端并不是我的强项。小伙伴在跟着这篇博客学习的时候,我会把我的整个项目的源码放到github上,源码戳这里,项目的WebContent目录下几个页面就是我们项目所需的页面(PS:如果写得不好请不要吐槽我,尽力了),当然前端页面与后台数据交互用到了JSON,还实现了AJAX技术,在页面代码里需要大家去揣摩,我就不多BB了。网页中文乱码想必是家常便饭,包括请求数据到后台乱码,前台页面展示乱码等等,这里我也解决好了,你自己去看我的项目源码,我是怎么去解决的,如果是你你会怎么去解决呢?

七、总结

写完一个项目,一定要去总结,这个项目什么地方我花费了很多时间,怎么去解决如何去解决,怎么样解决又快又好?我个人觉得思考问题本身比代码设计阶段更重要,如果没有思维过程,自己写得东西就像是套一个代码模板,下次别人换一个需求你可能就写不出来了,这也是很多刚入门的新手需要注意的地方,也是从一个码农到一个合格程序员必经之路!当然,新手刚开始只需要去多看别人写的,多去查一些资料,自己再去仿写出来就行了,久而久之你一定会有很多收获。

希望就该博客有什么问题或疑惑向我提供意见和建议,谢谢

没有更多推荐了,返回首页