Spring MVC 02 单例模式及统一异常处理

单例模式及统一异常处理

文章目录

单例模式及统一异常处理
- 一、学习目标与任务
- - - 1.1回顾提问：
    - 1.2学习目标
    - 1.3学习任务
- 二、单例模式
- - - 1.1.问题分析
    - 1.2单例模式的概念
    - 1.3单例模式实现的方式
    - - 1.3.1简单的单例模式实现
      - 1.3.2懒汉模式-`synchronized`
      - 1.3.3饿汉模式
      - 1.3.4饿汉模式-静态内部类
    - 1.4.Spring MVC中的单例模式
- 三、搭建项目运行环境
- - - 3.1.实现步骤
    - 3.2.改造登录、注销功能
    - 3.3.改造CVS-用户登录功能
    - - 3.3.1 web.xml配置
      - 3.3.2 applicationContext-jdbc.xml配置
      - 3.3.3 springmvc-servlet配置
      - 3.3.4 database.properties文件
      - 3.3.5 log4j.properties文件
      - 3.3.6 SysUserDao
      - 3.3.7 ConfigManager
      - 3.3.8 BaseDao
      - 3.3.9 SysUserDaoImpl
      - 3.3.10 SysUserService
      - 3.3.11 SysUserServiceImpl
      - 3.3.12 SysUserController
      - 3.3.13 login.jsp
      - 3.3.14 frame.jsp
      - 3.3.15 common/head.jsp
      - 3.3.16 common/foot.jsp
      - 3.3.17 maven pom.xml配置
      - 3.3.18 Constants 系统静态常量
- 四、静态资源文件的引用
- - - 4.1静态资源无法正常加载的原因
    - 4.2登录功能优化
- 五、异常处理
- - - 5.1异常处理
    - 5.2异常处理
- 六、改造用户列表查询功能
- - - 6.1需求说明
    - 6.2实现步骤
    - 6.3 练习—改造供货商列表查询功能
- 七、本章总结
- - - 7.1本章总结
- 八、监听器
- - - 8.1 ContextLoaderListener监听器作用

一、学习目标与任务 1.1回顾提问：

1.MVC设计模式是什么？

2.Spring MVC的架构是什么？

3.Spring MVC的请求处理流程是什么？

4.Spring MVC框架是基于哪个核心的Servlet？

5.Spring MVC如何实现View与Controller之间的参数传递？

1.2学习目标

掌握并理解单例模式
搭建SSM框架
掌握Spring MVC访问静态文件
掌握Servlet API作为控制器接口入参
掌握Spring MVC异常(局部、全局)处理

1.3学习任务

改造读取数据库配置文件的工具类为单例模式
改造724系统-登录、注销、查询用户列表功能
使用Spring MVC(局部)异常处理，提示登录失败的原因
使用Spring MVC(全局)异常处理，提示登录失败的原因
改造724系统-供货商列表查询功能

二、单例模式 1.1.问题分析

回顾学习JDBC操作数据库的基类(BaseDao.java)

database.properties文件

driver=com.mysql.cj.jdbc.Driver
#在和mysql传递数据的过程中，使用unicode编码格式，字符集设置为utf-8，并根据需要设置时区
url=jdbc:mysql://127.0.0.1:3306/cvs_db?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
user=root
password=root

ConfigManager工具类：

package cn.cvs.utils;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

//存在问题：每个线程操作数据库都需new一个BaseDao实例，即每个线程都会单独加载配置文件，影响系统性能
public class ConfigManager {
	private static Properties properties;
	static{
   init();
 } 
	public static void init(){
		String configFile = "database.properties";
		properties = new Properties();
		InputStream is = 
		ConfigManager.class.getClassLoader().getResourceAsStream(configFile);
		try {
			properties.load(is);
			is.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	public static String getProperty(String key){
		return properties.getProperty(key);
	}
}

BaseDao工具类：

package cn.cvs.dao;

import cn.cvs.utils.ConfigManager;

import java.sql.*;


public class BaseDao {

	
	public static Connection getConnection(){
		Connection connection = null;
		String driver = ConfigManager.getProperty("driver"); 
     String url = ConfigManager.getProperty("url");
     String user = ConfigManager.getProperty("user");
     String password = ConfigManager.getProperty("password");
		try {
			Class.forName(driver);
			connection = DriverManager.getConnection(url, user, password);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return connection;
	}
	
	public static ResultSet execute(Connection connection,PreparedStatement pstm,ResultSet rs,
			String sql,Object[] params) throws Exception{
		pstm = connection.prepareStatement(sql);
		for(int i = 0; i < params.length; i++){
			pstm.setObject(i+1, params[i]);
		}
		rs = pstm.executeQuery();
		return rs;
	}
	
	public static int execute(Connection connection,PreparedStatement pstm,
			String sql,Object[] params) throws Exception{
		int updateRows = 0;
		pstm = connection.prepareStatement(sql);
		for(int i = 0; i < params.length; i++){
			pstm.setObject(i+1, params[i]);
		}
		updateRows = pstm.executeUpdate();
		return updateRows;
	}
	
	
	public static boolean closeResource(Connection connection,PreparedStatement pstm,ResultSet rs){
		boolean flag = true;
		if(rs != null){
			try {
				rs.close();
				rs = null;//GC回收
			} catch (SQLException e) {
				e.printStackTrace();
				flag = false;
			}
		}
		if(pstm != null){
			try {
				pstm.close();
				pstm = null;//GC回收
			} catch (SQLException e) {
				e.printStackTrace();
				flag = false;
			}
		}
		if(connection != null){
			try {
				connection.close();
				connection = null;//GC回收
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				flag = false;
			}
		}
		
		return flag;
	}

}

问题1：

BaseDao：操作数据库的基类
- init()方法
  - 从配置文件中读取数据库连接的初始化参数
  - 读取配置文件属于I/O操作，十分消耗资源，影响系统性能
每个线程操作数据库都需new一个BaseDao实例，即每个线程都会单独加载配置文件，影响系统性能，该如何解决呢？

分析：

对于每个线程，可共享一个实例
单例模式

1.2单例模式的概念

单例模式：系统运行期间，有且仅有一个实例

一个类只有一个实例

私有构造方法

自行创建实例对象

定义了静态的该类私有对象

对外提供实例对象

提供一个静态的公有方法，返回创建的或者获取本身的静态私有对象

1.3单例模式实现的方式

1.3.1简单的单例模式实现

package cn.cvs.utils;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

//通过单例模式读取配置文件
public class ConfigManager {
   //1.定义静态实例属性
	private static ConfigManager configManager;
	private static Properties properties;
   
	//2.私有构造器-读取数据库配置文件
	private ConfigManager(){
		String configFile = "database.properties";
		properties = new Properties();
		InputStream is =
   ConfigManager.class.getClassLoader().getResourceAsStream(configFile);
		try {
		properties.load(is);
		is.close();
		 } catch (IOException e) {
			  e.printStackTrace();
		 }
	}

	//3.对外提供的获取ConfigManager实例的方法
	public static ConfigManager getInstance(){
		if(configManager == null){
		configManager = new ConfigManager();
		}
		return configManager;
	}

	public String getValue(String key){
		return properties.getProperty(key);
	}
}

问题2：

在并发环境下，上述的单例模式实现是否存在弊端，线程是否安全？是否会出现多个configManager实例？

分析：

懒汉模式
饿汉模式

1.3.2懒汉模式-synchronized

懒汉模式：

类加载时不创建实例，采用延迟加载的方式，在运行调用时创建实例
特点
线程不安全
延迟加载(Lazy Loading)
如何解决线程安全问题？
synchronized关键字
在方法中添加 synchronized 关键字：public static synchronized ConfigManager getInstance()

package cn.cvs.utils;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

//通过单例模式读取配置文件
public class ConfigManager {
	private static ConfigManager configManager;
	private static Properties properties;
	//私有构造器-读取数据库配置文件
	private ConfigManager(){
		String configFile = "database.properties";
		properties = new Properties();
		InputStream is =
				ConfigManager.class.getClassLoader().getResourceAsStream(configFile);
		try {
			properties.load(is);
			is.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	// 对外提供的获取ConfigManager实例的方法
	public static synchronized ConfigManager getInstance(){
		if(configManager == null){
			configManager = new ConfigManager();
		}
		return configManager;
	}

	public String getValue(String key){
		return properties.getProperty(key);
	}
}

1.3.3饿汉模式

类加载的时候，就完成初始化
特点
线程安全
不具备延迟加载特性

饿汉模式示例

直接创建实例对象：

private static ConfigManager configManager = new ConfigManager();

定义获取实例对象的方法getInstance:

public static ConfigManager getInstance()

package cn.cvs.utils;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

//通过单例模式读取配置文件
public class ConfigManager {

	private static ConfigManager configManager = new ConfigManager();
	private static Properties properties;
	
//私有构造器-读取数据库配置文件
	private ConfigManager(){
		String configFile = "database.properties";
		properties = new Properties();
		InputStream is =
				ConfigManager.class.getClassLoader().getResourceAsStream(configFile);
		try {
			properties.load(is);
			is.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	

	//饿汉模式
	public static ConfigManager getInstance(){
		return configManager;
	}

	public String getValue(String key){
		return properties.getProperty(key);
	}
}

问题3：

若实例化单例类(比如说：ConfigManager)很消耗资源，我们希望它可以延迟加载，即不想让它在类加载的时候就实例化，应该如何处理呢？

分析：

要求饿汉模式同时要具备延迟加载的特性
静态内部类

1.3.4饿汉模式-静态内部类

定义Single类，在类的内部增加内部静态类 SingleHelper

package cn.cvs.utils;

public class Single {
	
	private static Single single;
	
//私有化构造
	private Single(){
	   // 整个运行期间，只执行一次的业务代码操作，如：读取配置文件的操作。
//......
	}
	
	public static class SingleHelper{
		private static final Single INSTANCE = new Single();
	}
	//对外提供获取本实例的方法
	public static Single getInstance(){
		single = SingleHelper.INSTANCE;
		return single;
	}
	public static Single test(){
		return single;
	}
	
}

测试分别使用Single.test(); 与Single.getInstance();获取对象

package cn.cvs.utils;

public class TestSingle {
	public static void main(String[] args) {
		Single single = Single.test();
		System.out.println("调用Singleton.test()方法获取实例对象：" + single);

		single = Single.getInstance();
		System.out.println("第一次调用Singleton.getInstance()方法获取实例对象：" + single);

		single = Single.getInstance();
		System.out.println("第二次调用Singleton.getInstance()方法获取实例对象：" + single);
	}
}

运行结果：

学员操作—增加读取数据库配置文件的工具类

需求说明：

在上章学员操作的基础上增加ConfigManager.java的工具类完成数据库配置文件的读取
该类设计为单例模式，使用懒汉模式、饿汉模式、静态内部类等方式均可，但需要考虑线程安全问题。

1.4.Spring MVC中的单例模式

Spring MVC-Controller
- 默认scope为singleton
- 速度和性能优越
在Spring MVC的Controller中声明成员变量，需要注意线程安全问题
一般情况下，Controller内的成员变量就只有service对象

package cn.cvs.controller;
import cn.cvs.pojo.SysUser;
import org.apache.log4j.Logger;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;

@Controller
@RequestMapping("/user")
@Scope("prototype")//默认scope为singleton
public class SysUserController {
	private Logger logger = Logger.getLogger(SysUserController.class);

	private ArrayList userList = new ArrayList();
	// 用于返回查询到的用户数据
	private ArrayList queryUserList = new ArrayList();
	
 public SysUserController(){
			userList.add(new SysUser(5,"zhaojing","赵静","5555555",1
					, "13054784445","上海市宝山区",1,1,new Date(),1, new Date()));
			userList.add(new SysUser(4,"wanglin","王林","4444444",1
					,"18965652364","北京市学院路",1,1,new Date(),1,new Date()));
			userList.add(new SysUser(1,"test001","测试用户001","1111111",1
					, "13566669998","北京市朝阳区",1,1,new Date(),1, new Date()));
			userList.add(new SysUser(2,"zhaoyan","赵燕","2222222",1
					, "18678786545","北京市海淀区",1,1,new Date(),1, new Date()));
			userList.add(new SysUser(3,"test003","测试用户003","1111111",1
					,"13121334531","北京市海淀区",1,1,new Date(),1,new Date()));
	}

	
	@GetMapping("/list")
	public String list(Model model){
		logger.info("当查询条件位空时，查询用户信息" + this);
		queryUserList.clear();
		queryUserList.addAll(userList);
		model.addAttribute("queryUserList",userList);
		return "sysUser/sysUserList";
	}

	
	@PostMapping("/list")
	public String list(@RequestParam(value="realName",required=false) String realName, Model model){
		logger.info("查询条件：【realName】= " + realName +", 查询用户信息");
		queryUserList.clear();
		if(realName != null && !realName.equals("")){
			for(SysUser user:userList){
				if(user.getRealName().indexOf(realName) != -1){
					queryUserList.add(user);
				}
			}
		}else{
			queryUserList.addAll(userList);
		}
		model.addAttribute("queryUserList",queryUserList);
		return "sysUser/sysUserList";
	}
}

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



 
 查询用户信息


查询用户列表

 用户名称：
 



 
     id= ${sysUser.id };
     用户编码= ${sysUser.account };
     用户名称= ${sysUser.realName };
     用户密码= ${sysUser.password };
     用户地址= ${sysUser.address };

注意当控制器获取视图传递的值出现乱码时需要配置过滤器



     CharacterEncodingFilter
     org.springframework.web.filter.CharacterEncodingFilter
     
         encoding
         utf-8
     
 
 
     CharacterEncodingFilter
     
public interface SysUserDao {
        
        int insert(Connection connection, SysUser sysUser) throws Exception;

        
        SysUser findUserByAccount(Connection connection, String account) throws Exception;

        
        List findList(Connection connection, String realName, int userRoleId, int currentPageNo, int pageSize) throws Exception;

        
        int getTotalCount(Connection connection, String realName, int userRoleId) throws Exception;

        
        int deleteUserById(Connection connection, Integer id) throws Exception;


        
        SysUser getUserById(Connection connection, String id) throws Exception;

        
        int modify(Connection connection, SysUser user) throws Exception;


        
        int updatePwd(Connection connection, int id, String password) throws Exception;
}

3.3.7 ConfigManager

package com.aiden.springmvc.cvs.utils;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;


public class ConfigManager {

    private static ConfigManager configManager;
    private static Properties properties;
    //私有构造
    private ConfigManager() {
        String configFile = "database.properties";
        InputStream is = null;
        properties = new Properties();
        try {
            is = ConfigManager.class.getClassLoader().getResourceAsStream(configFile);
            properties.load(is);
            is.close();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    
    public static class ConfigManagerHelper {
        private static final ConfigManager CONFIG_MANAGER = new ConfigManager();
    }

    
    public static ConfigManager getInstance() {
        configManager = ConfigManagerHelper.CONFIG_MANAGER;
        return configManager;
    }

    public static String getProperty(String key) {
        return properties.getProperty(key);
    }
}

3.3.8 BaseDao

package com.aiden.springmvc.cvs.dao;

import com.aiden.springmvc.cvs.utils.ConfigManager;

import java.sql.*;


public class BaseDao {
    private static BaseDao baseDao = new BaseDao();

    
    private BaseDao() {
        getConnection();
    }

    
    public static BaseDao getInstance() {
        return baseDao;
    }

    
    public static Connection getConnection() {
        Connection connection = null;
        String driver = ConfigManager.getInstance().getProperty("driver");
        String url = ConfigManager.getInstance().getProperty("url");
        String user = ConfigManager.getInstance().getProperty("user");
        String password = ConfigManager.getInstance().getProperty("password");
        try {
            Class.forName(driver);//加载驱动
            connection = DriverManager.getConnection(url, user, password);//建立连接
        } catch (Exception e) {
            e.printStackTrace();
        }
        return connection;
    }

    
    public static ResultSet execute(Connection connection, PreparedStatement stmt, ResultSet rs,
                                    String sql, Object... params) throws Exception {
        stmt = connection.prepareStatement(sql);
        for (int i = 0; i < params.length; i++) {
            stmt.setObject(i + 1, params[i]);
        }
        rs = stmt.executeQuery();
        return rs;
    }

    
    public static int execute(Connection connection, PreparedStatement stmt,
                              String sql, Object... params) throws Exception {
        int updateRows = 0;
        stmt = connection.prepareStatement(sql);
        for (int i = 0; i < params.length; i++) {
            stmt.setObject(i + 1, params[i]);
        }
        updateRows = stmt.executeUpdate();
        return updateRows;
    }

    
    public static boolean closeResource(Connection connection, PreparedStatement stmt, ResultSet rs) {
        boolean flag = true;
        if (rs != null) {
            try {
                rs.close();
                rs = null;//GC回收
            } catch (SQLException e) {
                e.printStackTrace();
                flag = false;
            }
        }
        if (stmt != null) {
            try {
                stmt.close();
                stmt = null;//GC回收
            } catch (SQLException e) {
                e.printStackTrace();
                flag = false;
            }
        }
        if (connection != null) {
            try {
                connection.close();
                connection = null;//GC回收
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                flag = false;
            }
        }

        return flag;
    }
}

3.3.9 SysUserDaoImpl

package com.aiden.springmvc.cvs.dao.impl;

import com.aiden.springmvc.cvs.dao.BaseDao;
import com.aiden.springmvc.cvs.dao.SysUserDao;
import com.aiden.springmvc.cvs.pojo.SysUser;
import org.springframework.stereotype.Repository;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;


@Repository
public class SysUserDaoImpl implements SysUserDao {


   @Override
   public int insert(Connection connection, SysUser sysUser) throws Exception {
       PreparedStatement stmt = null;
       int updateRows = 0;
       if (null != connection) {
           String sql = "insert into t_sys_user (account,realName,password," +
                   "roleId,sex,birthday,phone,address,createTime,createUserId) " +
                   "values(?,?,?,?,?,?,?,?,?,?)";
           Object[] params = {sysUser.getAccount(), sysUser.getRealName(), sysUser.getPassword(),
                   sysUser.getRoleId(), sysUser.getSex(), sysUser.getBirthday(),
                   sysUser.getPhone(), sysUser.getAddress(), sysUser.getCreatedTime(), sysUser.getCreatedUserId()};
           updateRows = BaseDao.execute(connection, stmt, sql, params);
           BaseDao.closeResource(null, stmt, null);
       }
       return updateRows;
   }

   @Override
   public SysUser findUserByAccount(Connection connection, String account) throws Exception {
       PreparedStatement pstm = null;
       ResultSet rs = null;
       SysUser user = null;
       if (null != connection) {
           String sql = "select * from t_sys_user where account=?";
           Object[] params = {account};
           rs = BaseDao.execute(connection, pstm, rs, sql, params);
           if (rs.next()) {
               user = new SysUser();
               user.setId(rs.getInt("id"));
               user.setAccount(rs.getString("account"));
               user.setRealName(rs.getString("realName"));
               user.setPassword(rs.getString("password"));
               user.setSex(rs.getInt("sex"));
               user.setBirthday(rs.getDate("birthday"));
               user.setPhone(rs.getString("phone"));
               user.setAddress(rs.getString("address"));
               user.setRoleId(rs.getInt("roleId"));
               user.setCreatedUserId(rs.getInt("createdUserId"));
               user.setCreatedTime(rs.getTimestamp("createdTime"));
               user.setUpdatedUserId(rs.getInt("updatedUserId"));
               user.setUpdatedTime(rs.getTimestamp("updatedTime"));
           }
           BaseDao.closeResource(null, pstm, rs);
       }
       return user;
   }

   @Override
   public List findList(Connection connection, String realName, int userRoleId, int currentPageNo, int pageSize) throws Exception {
       PreparedStatement stmt = null;
       ResultSet rs = null;
       List userList = new ArrayList();
       if (connection != null) {
           StringBuffer sql = new StringBuffer();
           sql.append("select u.*,r.roleName as roleIdName from t_sys_user u,t_sys_role r where u.roleId = r.id");
           List

Spring MVC 02 单例模式及统一异常处理

菜单 入库记录信息 供货商信息 用户信息 修改密码 退出系统 "/>

Java相关栏目本月热门文章

菜单

入库记录信息

供货商信息

用户信息

修改密码

退出系统

"/>