- 1. servlet-api
- 1.1 servlet初始化
- 1.2 ServletContext和context-param
- 2. 什么是业务层
- 3. IOC
- 3.1 耦合/依赖
- 3.2 IOC - 控制反转 / DI - 依赖注入
- 4.Filter
- 4.1 增加Filter-设置编码
- 5. 事务管理
- 5.1 编程式事务管理
- 5.2 Threadlocal
- 5.3 事务管理的实现
- 问题:DAO报错但是事务没有回滚
- 6. 监听器Listener
- 6.1 ServletContextListener的应用 - ContextLoaderListener
- review
代码重工
1. servlet-apiservlet生命周期: 实例化、初始化、服务、销毁
1.1 servlet初始化Servlet中的初始化方法有两个:init() , init(config)
其中带参数的方法代码如下:
public void init(ServletConfig config) throws ServletException {
this.config = config ;
init();
}
另外一个无参的init方法如下:
public void init() throws ServletException{
}
如果我们想要在Servlet初始化时做一些准备工作,那么我们可以重写init方法
我们可以通过如下步骤去获取初始化设置的数据
- 获取config对象:ServletConfig config = getServletConfig();
- 获取初始化参数值: config.getInitParameter(key);
在web.xml文件中配置Servlet初始化参数
Demo01Servlet com.atguigu.servlet.Demo01Servlet hello world uname jim Demo01Servlet /demo01
也可以通过注解的方式进行配置:
@WebServlet(urlPatterns = {"/demo01"} ,
initParams = {
@WebInitParam(name="hello",value="world"),
@WebInitParam(name="uname",value="jim")
})
1.2 ServletContext和context-param
context就是application(servletContext),多个用户可以共享这个值
- 获取ServletContext,有很多方法
在初始化方法中: ServletContxt servletContext = getServletContext();
在服务方法中也可以通过request对象获取,也可以通过session获取:
request.getServletContext(); session.getServletContext() - 获取初始化值:
servletContext.getInitParameter();
MVC:经典的架构模式
Model1和Model2
MVC : Model(模型)、View(视图)、Controller(控制器)
视图层:用于做数据展示以及和用户交互的一个界面
控制层:能够接受客户端的请求,具体的业务功能还是需要借助于模型组件来完成
模型层:模型分为很多种:有比较简单的pojo/vo(value object),有业务模型组件,有数据访问层组件
1) pojo/vo : 值对象
2) DAO : 数据访问对象
3) BO : 业务对象
区分业务对象和数据访问对象:
1) DAO中的方法都是单精度方法或者称之为细粒度方法。什么叫单精度?一个方法只考虑一个操作,比如添加,那就是insert操作、查询那就是select操作…
2) BO中的方法属于业务方法,也实际的业务是比较复杂的,因此业务方法的粒度是比较粗的
注册这个功能属于业务功能,也就是说注册这个方法属于业务方法。
那么这个业务方法中包含了多个DAO方法。也就是说注册这个业务功能需要通过多个DAO方法的组合调用,从而完成注册功能的开发。
注册:
1. 检查用户名是否已经被注册 - DAO中的select操作
2. 向用户表新增一条新用户记录 - DAO中的insert操作
3. 向用户积分表新增一条记录(新用户默认初始化积分100分) - DAO中的insert操作
4. 向系统消息表新增一条记录(某某某新用户注册了,需要根据通讯录信息向他的联系人推送消息) - DAO中的insert操作
5. 向系统日志表新增一条记录(某用户在某IP在某年某月某日某时某分某秒某毫秒注册) - DAO中的insert操作
6. …
3) 在库存系统中添加业务层组件
添加service层
package com.atguigu.fruit.service;
import com.atguigu.fruit.pojo.Fruit;
import java.util.List;
public interface FruitService {
//获取指定页面的库存列表信息
List getFruitList(String keyword , Integer pageNo);
//添加库存记录信息
void addFruit(Fruit fruit);
//根据id查看指定库存记录
Fruit getFruitByFid(Integer fid);
//删除特定库存记录
void delFruit(Integer fid);
//获取总页数
Integer getPageCount(String keyword);
//修改特定库存记录
void updateFruit(Fruit fruit);
}
3. IOC
3.1 耦合/依赖
依赖指的是某某某离不开某某某
在软件系统中,层与层之间是存在依赖的。我们也称之为耦合。
我们系统架构或者是设计的一个原则是: 高内聚低耦合。
层内部的组成应该是高度聚合的,而层与层之间的关系应该是低耦合的,最理想的情况0耦合(就是没有耦合)
步骤:
将服务层的FruitServiceImpl的
private FruitDAO fruitDAO = new FruitDAOImpl;
改为
private FruitDAO fruitDAO = null ;
FruitController中
private FruitService fruitService = new FruitServiceImpl ;
也改成
private FruitService fruitService = null ;
怎么解决空指针问题?
通过配置i文件,标签,组件。
在启动的时候,会将这三个组件准备好,放在容器里面。谁想要就主动给谁。
定义一个获取bean对象的接口,需要一个map容器
package com.atguigu.myssm.io;
public interface BeanFactory {
Object getBean(String id);
}
实现这个接口
package com.atguigu.myssm.io;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
public class ClassPathXmlApplicationContext implements BeanFactory {
private Map beanMap = new HashMap<>();
public ClassPathXmlApplicationContext(){
try {
InputStream inputStream = getClass().getClassLoader().getResourceAsStream("applicationContext.xml");
//1.创建DocumentBuilderFactory
DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
//2.创建DocumentBuilder对象
DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder() ;
//3.创建Document对象
Document document = documentBuilder.parse(inputStream);
//4.获取所有的bean节点
NodeList beanNodeList = document.getElementsByTagName("bean");
for(int i = 0 ; i
Node beanNode = beanNodeList.item(i);
if(beanNode.getNodeType() == Node.ELEMENT_NODE){
Element beanElement = (Element)beanNode ;
String beanId = beanElement.getAttribute("id");
String className = beanElement.getAttribute("class");
Class beanClass = Class.forName(className);
//创建bean实例
Object beanObj = beanClass.newInstance() ;
//将bean实例对象保存到map容器中
beanMap.put(beanId , beanObj) ;
//到目前为止,此处需要注意的是,bean和bean之间的依赖关系还没有设置
}
}
//5.组装bean之间的依赖关系
for(int i = 0 ; i
Node beanNode = beanNodeList.item(i);
if(beanNode.getNodeType() == Node.ELEMENT_NODE) {
Element beanElement = (Element) beanNode;
String beanId = beanElement.getAttribute("id");
NodeList beanChildNodeList = beanElement.getChildNodes();
for (int j = 0; j < beanChildNodeList.getLength() ; j++) {
Node beanChildNode = beanChildNodeList.item(j);
if(beanChildNode.getNodeType()==Node.ELEMENT_NODE && "property".equals(beanChildNode.getNodeName())){
Element propertyElement = (Element) beanChildNode;
String propertyName = propertyElement.getAttribute("name");
String propertyRef = propertyElement.getAttribute("ref");
//1) 找到propertyRef对应的实例
Object refObj = beanMap.get(propertyRef);
//2) 将refObj设置到当前bean对应的实例的property属性上去
Object beanObj = beanMap.get(beanId);
Class beanClazz = beanObj.getClass();
Field propertyField = beanClazz.getDeclaredField(propertyName);
propertyField.setAccessible(true);
propertyField.set(beanObj,refObj);
}
}
}
}
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
}
@Override
public Object getBean(String id) {
return beanMap.get(id);
}
}
改动DispatcherServlet,获取beanFactory
public class DispatcherServlet extends ViewBaseServlet{
private BeanFactory beanFactory ;
public DispatcherServlet(){
}
public void init() throws ServletException {
super.init();
beanFactory = new ClassPathXmlApplicationContext();
}
在配置文件中
48 30:29
在ClassPathXmlApplicationContext中组装bean之间的依赖关系
//5.组装bean之间的依赖关系
for(int i = 0 ; i
Node beanNode = beanNodeList.item(i);
if(beanNode.getNodeType() == Node.ELEMENT_NODE) {
Element beanElement = (Element) beanNode;
String beanId = beanElement.getAttribute("id");
NodeList beanChildNodeList = beanElement.getChildNodes();
for (int j = 0; j < beanChildNodeList.getLength() ; j++) {
Node beanChildNode = beanChildNodeList.item(j);
if(beanChildNode.getNodeType()==Node.ELEMENT_NODE && "property".equals(beanChildNode.getNodeName())){
Element propertyElement = (Element) beanChildNode;
String propertyName = propertyElement.getAttribute("name");
String propertyRef = propertyElement.getAttribute("ref");
//1) 找到propertyRef对应的实例
Object refObj = beanMap.get(propertyRef);
//2) 将refObj设置到当前bean对应的实例的property属性上去
Object beanObj = beanMap.get(beanId);
Class beanClazz = beanObj.getClass();
Field propertyField = beanClazz.getDeclaredField(propertyName);
propertyField.setAccessible(true);
propertyField.set(beanObj,refObj);
}
}
}
}
3.2 IOC - 控制反转 / DI - 依赖注入
这就是每层之间都解耦了,但是都依赖ApplicationContext容器,容器又是读取配置文件,所以最终个模块只依赖配置文件的参数。
控制反转:
1) 之前在Servlet中,我们创建service对象 , FruitService fruitService = new FruitServiceImpl();
这句话如果出现在servlet中的某个方法内部,那么这个fruitService的作用域(生命周期)应该就是这个方法级别;
如果这句话出现在servlet的类中,也就是说fruitService是一个成员变量,那么这个fruitService的作用域(生命周期)应该就是这个servlet实例级别
2) 之后我们在applicationContext.xml中定义了这个fruitService。然后通过解析XML,产生fruitService实例,存放在beanMap中,这个beanMap在一个BeanFactory中
因此,我们转移(改变)了之前的service实例、dao实例等等他们的生命周期。控制权从程序员转移到BeanFactory。这个现象我们称之为控制反转
依赖注入:
1) 之前我们在控制层出现代码:FruitService fruitService = new FruitServiceImpl();
那么,控制层和service层存在耦合。
2) 之后,我们将代码修改成FruitService fruitService = null ;
然后,在配置文件中配置:
依赖注入是IOC的具体实现
4.Filter- Filter也属于Servlet规范
- Filter开发步骤:新建类实现Filter接口,然后实现其中的三个方法:init、doFilter、destroy
配置Filter,可以用注解@WebFilter,也可以使用xml文件 - Filter在配置时,和servlet一样,也可以配置通配符,例如 @WebFilter(“*.do”)表示拦截所有以.do结尾的请求
- 过滤器链
1)执行的顺序依次是: A B C demo03 C2 B2 A2
2)如果采取的是注解的方式进行配置,那么过滤器链的拦截顺序是按照全类名的先后顺序排序的
3)如果采取的是xml的方式进行配置,那么按照配置的先后顺序进行排序
package com.atguigu.filters;
import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;
//@WebFilter("/demo01.do")
@WebFilter("*.do")
public class Demo01Filter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
System.out.println("helloA");
//放行
filterChain.doFilter(servletRequest,servletResponse);
System.out.println("helloA2");
}
@Override
public void destroy() {
}
}
4.1 增加Filter-设置编码
package com.atguigu.myssm.filters;
import com.atguigu.myssm.util.StringUtil;
import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.annotation.WebInitParam;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
@WebFilter(urlPatterns = {"*.do"},initParams = {@WebInitParam(name = "encoding",value = "UTF-8")})
public class CharacterEncodingFilter implements Filter {
private String encoding = "UTF-8";
@Override
public void init(FilterConfig filterConfig) throws ServletException {
String encodingStr = filterConfig.getInitParameter("encoding");
if(StringUtil.isNotEmpty(encodingStr)){
encoding = encodingStr ;
}
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
((HttpServletRequest)servletRequest).setCharacterEncoding(encoding); // 完成设置编码
filterChain.doFilter(servletRequest,servletResponse);// 放行
}
@Override
public void destroy() {
}
}
5. 事务管理
5.1 编程式事务管理
事务管理的操作不能写在DAO层。
service的操作应该是一个整体,不能部分成功部分失败。
事务管理不能以DAO层的单精度方法为单位,而应该以业务层的方法为单位
解决方法:
进一步利用Filter进行事务管理,
DAO1、2、3这三个组件中的三个操作需要同一个Connection,这样我们才可以让三个操作处于一个事务中。
如何解决?
链接
- get() , set(obj)
- ThreadLocal称之为本地线程 。 我们可以通过set方法在当前线程上存储数据、通过get方法在当前线程上获取数据
-set方法源码分析:
public void set(T value) {
Thread t = Thread.currentThread(); //获取当前的线程
ThreadLocalMap map = getMap(t); //每一个线程都维护各自的一个容器(ThreadLocalMap)
if (map != null)
map.set(this, value); //这里的key对应的是ThreadLocal,因为我们的组件中需要传输(共享)的对象可能会有多个(不止Connection)
else
createMap(t, value); //默认情况下map是没有初始化的,那么第一次往其中添加数据时,会去初始化
}
-get方法源码分析:
public T get() {
Thread t = Thread.currentThread(); //获取当前的线程
ThreadLocalMap map = getMap(t); //获取和这个线程(企业)相关的ThreadLocalMap(也就是工作纽带的集合)
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this); //this指的是ThreadLocal对象,通过它才能知道是哪一个工作纽带
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value; //entry.value就可以获取到工具箱了
return result;
}
}
return setInitialValue();
}
一句话理解ThreadLocal,threadlocl是作为当前线程中属性ThreadLocalMap集合中的某一个Map的key值Map(threadlocl,value),虽然不同的线程之间threadlocal这个key值是一样,但是不同的线程所拥有的ThreadLocalMap是独一无二的,也就是不同的线程间同一个ThreadLocal(key)对应存储的值(value)不一样,从而到达了线程间变量隔离的目的,但是同一个线程中这个变量value是一样的。
同一个线程来实现事务控制
5.3 事务管理的实现涉及到的组件:
- OpenSessionInViewFilter
- TransactionManager
- ThreadLocal
- ConnUtil
- BaseDAO
com.atguigu.myssm.filters.OpenSessionInViewFilter
将开启事务,提交事务,回滚事务封装成一个类。
com.atguigu.myssm.trans.TransactionManager 将获取到的conn放在Threadlocal里。
connection如何获取?
由com.atguigu.myssm.basedao.ConnUtil获取connection
package com.atguigu.myssm.filters;
import com.atguigu.myssm.trans.TransactionManager;
import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;
import java.sql.SQLException;
@WebFilter("*.do")
public class OpenSessionInViewFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
try{
TransactionManager.beginTrans();
System.out.println("开启事务....");
filterChain.doFilter(servletRequest, servletResponse);
TransactionManager.commit();
System.out.println("提交事务...");
}catch (Exception e){
e.printStackTrace();
try {
TransactionManager.rollback();
System.out.println("回滚事务....");
} catch (SQLException ex) {
ex.printStackTrace();
}
}
}
@Override
public void destroy() {
}
}
package com.atguigu.myssm.trans;
import com.atguigu.myssm.basedao.ConnUtil;
import java.sql.Connection;
import java.sql.SQLException;
public class TransactionManager {
//开启事务
public static void beginTrans() throws SQLException {
ConnUtil.getConn().setAutoCommit(false);
}
//提交事务
public static void commit() throws SQLException {
Connection conn = ConnUtil.getConn();
conn.commit();
ConnUtil.closeConn();
}
//回滚事务
public static void rollback() throws SQLException {
Connection conn = ConnUtil.getConn();
conn.rollback();
ConnUtil.closeConn();
}
}
package com.atguigu.myssm.basedao;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class ConnUtil {
private static ThreadLocal threadLocal = new ThreadLocal<>();
//private static ThreadLocal
问题:DAO报错但是事务没有回滚
链接
因为DAO层的try catch捕捉到了异常。所以filter没有捕捉到异常,没有进行事务回滚。
解决方法:将DAO层的报错都往出抛,按道理要封装出自定义异常,不同的层设计不同的异常
可以捕捉到了以后,抛出自定义异常
package com.atguigu.myssm.basedao;
public class DAOException extends RuntimeException{
public DAOException(String msg){
super(msg);
}
}
package com.atguigu.myssm.basedao; import java.lang.reflect.Field; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.sql.*; import java.util.ArrayList; import java.util.List; public abstract class BaseDAO6. 监听器Listener{ protected Connection conn ; protected PreparedStatement psmt ; protected ResultSet rs ; //T的Class对象 private Class entityClass ; public BaseDAO() { //getClass() 获取Class对象,当前我们执行的是new FruitDAOImpl() , 创建的是FruitDAOImpl的实例 //那么子类构造方法内部首先会调用父类(BaseDAO)的无参构造方法 //因此此处的getClass()会被执行,但是getClass获取的是FruitDAOImpl的Class //所以getGenericSuperclass()获取到的是BaseDAO的Class Type genericType = getClass().getGenericSuperclass(); //ParameterizedType 参数化类型 Type[] actualTypeArguments = ((ParameterizedType) genericType).getActualTypeArguments(); //获取到的 中的T的真实的类型 Type actualType = actualTypeArguments[0]; try { entityClass = Class.forName(actualType.getTypeName()); } catch (ClassNotFoundException e) { e.printStackTrace(); throw new DAOException("BaseDAO 构造方法出错了,可能的原因是没有指定<>中的类型"); } } protected Connection getConn(){ return ConnUtil.getConn(); } protected void close(ResultSet rs , PreparedStatement psmt , Connection conn){ } //给预处理命令对象设置参数 private void setParams(PreparedStatement psmt , Object... params) throws SQLException { if(params!=null && params.length>0){ for (int i = 0; i < params.length; i++) { psmt.setObject(i+1,params[i]); } } } //执行更新,返回影响行数 protected int executeUpdate(String sql , Object... params) { boolean insertFlag = false ; insertFlag = sql.trim().toUpperCase().startsWith("INSERT"); conn = getConn(); try{ if(insertFlag){ psmt = conn.prepareStatement(sql,Statement.RETURN_GENERATED_KEYS); }else { psmt = conn.prepareStatement(sql); } setParams(psmt,params); int count = psmt.executeUpdate() ; if(insertFlag){ rs = psmt.getGeneratedKeys(); if(rs.next()){ return ((Long)rs.getLong(1)).intValue(); } } return 0 ; }catch (SQLException e){ e.printStackTrace(); throw new DAOException("BaseDAO executeUpdate出错了"); } } //通过反射技术给obj对象的property属性赋propertyValue值 private void setValue(Object obj , String property , Object propertyValue) throws NoSuchFieldException, IllegalAccessException { Class clazz = obj.getClass(); //获取property这个字符串对应的属性名 , 比如 "fid" 去找 obj对象中的 fid 属性 Field field = clazz.getDeclaredField(property); if(field!=null){ field.setAccessible(true); field.set(obj,propertyValue); } } //执行复杂查询,返回例如统计结果 protected Object[] executeComplexQuery(String sql , Object... params){ conn = getConn() ; try{ psmt = conn.prepareStatement(sql); setParams(psmt,params); rs = psmt.executeQuery(); //通过rs可以获取结果集的元数据 //元数据:描述结果集数据的数据 , 简单讲,就是这个结果集有哪些列,什么类型等等 ResultSetMetaData rsmd = rs.getMetaData(); //获取结果集的列数 int columnCount = rsmd.getColumnCount(); Object[] columnValueArr = new Object[columnCount]; //6.解析rs if(rs.next()){ for(int i = 0 ; i Object columnValue = rs.getObject(i+1); //33 苹果 5 columnValueArr[i]=columnValue; } return columnValueArr ; } }catch(SQLException e){ e.printStackTrace(); throw new DAOException("BaseDAO executeComplexQuery出错了"); } return null ; } //执行查询,返回单个实体对象 protected T load(String sql , Object... params){ conn = getConn() ; try{ psmt = conn.prepareStatement(sql); setParams(psmt,params); rs = psmt.executeQuery(); //通过rs可以获取结果集的元数据 //元数据:描述结果集数据的数据 , 简单讲,就是这个结果集有哪些列,什么类型等等 ResultSetMetaData rsmd = rs.getMetaData(); //获取结果集的列数 int columnCount = rsmd.getColumnCount(); //6.解析rs if(rs.next()){ T entity = (T)entityClass.newInstance(); for(int i = 0 ; i String columnName = rsmd.getColumnName(i+1); //fid fname price Object columnValue = rs.getObject(i+1); //33 苹果 5 setValue(entity,columnName,columnValue); } return entity ; } }catch (Exception e){ e.printStackTrace(); throw new DAOException("BaseDAO load出错了"); } return null ; } //执行查询,返回List protected List executeQuery(String sql , Object... params){ List list = new ArrayList<>(); conn = getConn() ; try{ psmt = conn.prepareStatement(sql); setParams(psmt,params); rs = psmt.executeQuery(); //通过rs可以获取结果集的元数据 //元数据:描述结果集数据的数据 , 简单讲,就是这个结果集有哪些列,什么类型等等 ResultSetMetaData rsmd = rs.getMetaData(); //获取结果集的列数 int columnCount = rsmd.getColumnCount(); //6.解析rs while(rs.next()){ T entity = (T)entityClass.newInstance(); for(int i = 0 ; i String columnName = rsmd.getColumnName(i+1); //fid fname price Object columnValue = rs.getObject(i+1); //33 苹果 5 setValue(entity,columnName,columnValue); } list.add(entity); } }catch (Exception e){ e.printStackTrace(); throw new DAOException("BaseDAO executeQuery出错了"); } return list ; } }
1) ServletContextListener - 监听ServletContext对象的创建和销毁的过程 2) HttpSessionListener - 监听HttpSession对象的创建和销毁的过程 3) ServletRequestListener - 监听ServletRequest对象的创建和销毁的过程 4) ServletContextAttributeListener - 监听ServletContext的保存作用域的改动(add,remove,replace) 5) HttpSessionAttributeListener - 监听HttpSession的保存作用域的改动(add,remove,replace) 6) ServletRequestAttributeListener - 监听ServletRequest的保存作用域的改动(add,remove,replace) 7) HttpSessionBindingListener - 监听某个对象在Session域中的创建与移除 8) HttpSessionActivationListener - 监听某个对象在Session域中的序列化和反序列化
package com.atguigu.listener;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;
//@WebListener
public class MyServletContextListener implements ServletContextListener {
@Override
public void contextInitialized(ServletContextEvent servletContextEvent) {
System.out.println("Servlet上下文对象初始化动作被我监听到了....");
}
@Override
public void contextDestroyed(ServletContextEvent servletContextEvent) {
System.out.println("Servlet上下文对象销毁动作被我监听到了.....");
}
}
6.1 ServletContextListener的应用 - ContextLoaderListener
在DispatcherServlet的初始化方法中创建了IOC的beanFactory
最好的情况是当前上下文被启动的时候,IOC的beanFactory就准备就绪。启动性能虽然低,但是响应的性能很高。
移到Listener中
package com.atguigu.myssm.listeners;
import com.atguigu.myssm.ioc.BeanFactory;
import com.atguigu.myssm.ioc.ClassPathXmlApplicationContext;
import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;
//监听上下文启动,在上下文启动的时候去创建IOC容器,然后将其保存到application作用域
//后面中央控制器再从application作用域中去获取IOC容器
@WebListener
public class ContextLoaderListener implements ServletContextListener {
@Override
public void contextInitialized(ServletContextEvent servletContextEvent) {
//1.获取ServletContext对象
ServletContext application = servletContextEvent.getServletContext();
//2.获取上下文的初始化参数
String path = application.getInitParameter("contextConfigLocation");
//3.创建IOC容器
BeanFactory beanFactory = new ClassPathXmlApplicationContext(path);
//4.将IOC容器保存到application作用域
application.setAttribute("beanFactory",beanFactory);
}
@Override
public void contextDestroyed(ServletContextEvent servletContextEvent) {
}
}
然后在DispatcherServlet 中直接获取ServletContext
@WebServlet("*.do")
public class DispatcherServlet extends ViewBaseServlet{
private BeanFactory beanFactory ;
public DispatcherServlet(){
}
public void init() throws ServletException {
super.init();
//之前是在此处主动创建IOC容器的
//现在优化为从application作用域去获取
//beanFactory = new ClassPathXmlApplicationContext();
ServletContext application = getServletContext();
Object beanFactoryObj = application.getAttribute("beanFactory");
if(beanFactoryObj!=null){
beanFactory = (BeanFactory)beanFactoryObj ;
}else{
throw new RuntimeException("IOC容器获取失败!");
}
}
review
链接



