IOC
容器的初始化过程(定义各种bean
对象以及bean
对象间的关系),整个过程分成resource
的定位、载入和解析。IOC
容器的依赖注入,Bean
的名字通过ApplicationContext
容器,getbean
获得对应的bean
。
4.2.2 Spring IOC的理解
传统创建对象的缺陷:
传统创建对象,通过关键字new
获得。但是如果在不同的地方创建很多相同的对象,不仅占用很大的内存,同时影响性能。
改进思路:
仿造工厂模式,需要什么对象,直接拿过来,按照用户需求,组装相应的产品。以后不再通过new
获取对象,而是需要什么对象,就在spring
容器中取就行了。这就是将创建对象这个行为,进行控制反转,交由容器去完成。什么时候需要这些对象,再通过依赖注入的方式去获取这些对象。
依赖注入的几种方式
- 注解方式注入
<!-- 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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<!-- 打开Spring的Annotation支持 -->
<context:annotation-config/>
<!-- 设定Spring 去哪些包中找Annotation -->
<context:component-scan base-package="org.zttc.itat.spring"/>
</beans>
// 等价于<bean id="userDAO" class="cn.edu.ujn.dao.impl.UserDAO">
// 公共创建bean的annototion
@Component("userDAO")
// 一般用于DAO的注入,Spring3新增注解方式
@Repository("userDAO")
@Scope("prototype")
public class UserDAO implements IUserDAO {
......
}
@Component("userService")
//@Service一般用于业务层
@Service("userService")
public class UserService implements IUserService {
private IUserDAO userDAO;
public IUserDAO getUserDAO() {
return userDAO;
}
// 默认通过名称进行注入,在JSR330中提供了@Inject来进行注入,需导入相应的包
@Resource
public void setUserDAO(IUserDAO userDAO) {
this.userDAO = userDAO;
}
...
}
@Component("userAction")
//MVC的控制层一般使用@Controller
@Controller("userAction")
@Scope("prototype")
public class UserAction extends ActionSupport {
......
}
注:项目较大时,按照模块进行划分,模块中再按层划分,而非按层(MVC)进行划分;中小型项目按层划分。
2. Setter方法注入
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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<!--
创建如下bean等于完成了:HelloWorld helloWorld = new HelloWorld()
-->
<bean id="helloWorld" class="org.zttc.itat.spring.model.HelloWorld" scope="prototype"/>
<!-- 创建了一个User对象user,id为1,username为悟空,如果要注入值不使用ref而是使用value -->
<bean id="user" class="org.zttc.itat.spring.model.User">
<property name="id" value="2"/>
<property name="username" value="八戒"/>
</bean>
<bean id="userDao" class="org.zttc.itat.spring.dao.UserDao"></bean>
<bean id="userJDBCDao" class="org.zttc.itat.spring.dao.UserJDBCDao"></bean>
<!-- autowire=byName表示会根据name来完成注入,
byType表示根据类型注入 ,使用byType注入如果一个类中有两个同类型的对象就会抛出异常
所以在开发中一般都是使用byName
虽然自动注入可以减少配置,但是通过bean文件无法很好了解整个类的结果,所以不建议使用autowire-->
<bean id="userService" class="org.zttc.itat.spring.service.UserService">
<!-- name中的值会在userService对象中调用setXX方法来注入,诸如:name="userDao"
在具体注入时会调用setUserDao(IUserDao userDao)来完成注入
ref="userDao"表示是配置文件中的bean中所创建的DAO的id -->
<property name="userDao" ref="userDao"></property>
</bean>
<!-- 对于UserAction而言,里面的属性的值的状态会根据不同的线程得到不同的值,所以应该使用多例 -->
<bean id="userAction" class="org.zttc.itat.spring.action.UserAction" scope="prototype">
<property name="userService" ref="userService"/>
<property name="user" ref="user"/>
<property name="id" value="12"/>
<!-- 同样可以注入列表,但是也不常用 -->
<property name="names">
<list>
<value>aaa</value>
<value>bbb</value>
<value>ccc</value>
</list>
</property>
</bean>
<!-- 以下是使用构造函数来注入,不常用,基本都是使用set方法注入 -->
<!-- <bean id="userAction" class="org.zttc.itat.spring.action.UserAction" scope="prototype">
<constructor-arg ref="userService"/>
</bean> -->
</beans>
public class UserAction{
private UserService userService;
public String login(){
userService.valifyUser(xxx);
}
public void setUserService(UserService userService){
this.userService = userService;
}
}
3. 构造方法注入
public class UserAction{
private final UserService userService;
public String login(){
userService.valifyUser(xxx);
}
public UserAction(UserService userService){
this.userService = userService;
}
}
三种注入方式对比
- 注解方式注入:适用于中小型项目,不适合大型项目。因为大型项目中存在很多的包、类,书写较复杂,且不易明白项目的整体结构。
- Setter 注入:对于习惯了传统
javabean
开发的程序员,通过setter
方法设定依赖关系更加直观。如果依赖关系较为复杂,那么构造子注入模式的构造函数也会相当庞大,而此时注入模式则更为简洁。- 构造器注入:在构造期间完成一个完整的、合法的对象。 所有依赖关系在构造函数中集中呈现。依赖关系在构造时由容器一次性设定,组件被创建之后一直处于相对“不变”的稳定状态。只有组件的创建者关心其内部依赖关系,对调用者而言,该依赖关系处于“黑盒”之中。如果用到了第三方类库,可能要求我们的组件提供一个默认的构造函数,此时构造器注入模式也不适用。
4.2.3 AOP 切面编程
很多项目上相应的业务处理上上需要事务和日志的管理,然而许多业务上的事务、日志代码又都是一样的,这样就造成了代码重复。
改进思路:
让这些重复的代码抽取出来,让专门的一个类进行管理。
AOP的实现:
在需要的地方加上通知(可以在目标代码前后执行),将相同的业务交由代理类去执行(比如日志、事务),然后再执行目标类,实现了代码复用。
静态代理的缺陷:
相同的业务交由代理类去处理,那么需要日志管理,就要创建一个日志代理类,需要事务管理,就要创建事务代理类……,这样会造成代理类的无限膨胀。
改进措施:
根据这些类,动态创建代理类。所以在这个过程,要实现两个步骤:
1.通过反射机制产生代理类;
2. 代理类要实现一个统一的接口,该接口可对目标类实现额外功能的附加,如在目标类前面加日志、事务等。
基于注解的AOP
实现逻辑如下:
package org.zttc.itat.spring.proxy;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
@Component("logAspect")//让这个切面类被Spring所管理
@Aspect//申明这个类是一个切面类
public class LogAspect {
/\*\*
\* execution(\* org.zttc.itat.spring.dao.\*.add\*(..))
\* 第一个\*表示任意返回值
\* 第二个\*表示 org.zttc.itat.spring.dao包中的所有类
\* 第三个\*表示以add开头的所有方法
\* (..)表示任意参数
\*/
@Before("execution(\* org.zttc.itat.spring.dao.\*.add\*(..))||" +
"execution(\* org.zttc.itat.spring.dao.\*.delete\*(..))||" +
"execution(\* org.zttc.itat.spring.dao.\*.update\*(..))")
public void logStart(JoinPoint jp) {
//得到执行的对象
System.out.println(jp.getTarget());
//得到执行的方法
System.out.println(jp.getSignature().getName());
Logger.info("加入日志");
}
/\*\*
\* 函数调用完成之后执行
\* @param jp
\*/
@After("execution(\* org.zttc.itat.spring.dao.\*.add\*(..))||" +
"execution(\* org.zttc.itat.spring.dao.\*.delete\*(..))||" +
"execution(\* org.zttc.itat.spring.dao.\*.update\*(..))")
public void logEnd(JoinPoint jp) {
Logger.info("方法调用结束加入日志");
}
/\*\*
\* 函数调用中执行
\* @param pjp
\* @throws Throwable
\*/
@Around("execution(\* org.zttc.itat.spring.dao.\*.add\*(..))||" +
"execution(\* org.zttc.itat.spring.dao.\*.delete\*(..))||" +
"execution(\* org.zttc.itat.spring.dao.\*.update\*(..))")
public void logAround(ProceedingJoinPoint pjp) throws Throwable {
Logger.info("开始在Around中加入日志");
pjp.proceed();//执行程序
Logger.info("结束Around");
}
}
4.2.4 动态代理的实现
动态代理主要实现了两个功能:
- 实现
InvocationHandler
接口中的invoke
方法(主要是被代理类实例、方法、方法参数),该方法就是对被代理对象加的额外操作,如添加日志、权限等。- 在运行时产生一个代理实例(通过反射)。
代码实现如下:
Proxy.newProxyInstance(ClassLoad loader, Class[] interfaces,InvocationHandler h)
// 要代理的真实对象
RealSubject rs = new RealSubject();
// 要代理哪个真实对象,就将该对象传进去,最后是通过该真实对象来调用其方法
InvocationHandler invocationHandler = new DynamicSubject(rs);
Class cl = rs.getClass();
Subject subject = (Subject) Proxy.newProxyInstance(cl.getClassLoader(), cl.getInterfaces(), invocationHandler);
// 代理对象执行方法
subject.request();
过程如下:
- 通过被代理类实例反射获得类类型;
- 然后将这个类类型进行加载(
ClassLoad loader
),实现代理类的接口方法(Class[] interfaces
),实现代理的invoke
方法;
总结:其实动态代理就是通过反射产生代理实例(Proxy.newProxyInstance
),然后通过invoke
实现额外功能的附加和代理方法的聚合。通过被代理类动态生成代理类解决了上面为各个被代理类创建相应的代理类,造成类膨胀的问题。
动态代理实现步骤:
- 创建一个实现接口
InvocationHandler
的类,它必须实现invoke
方法; - 创建被代理的类以及接口(通过被代理类的实例进行反射获得);
- 调用
Proxy
的静态方法,创建一个代理类new ProxyInstance(ClassLoad loader, Class[] interfaces,InvocationHandler h)
。 - 通过代理类返回的实例,去调用被代理类的方法;
4.2.5 jdk代理 和 CGlib动态代理 的区别
1. jdk动态代理
- 只能代理实现了接口
InvocationHandler
的类;- 没有实现
InvocationHandler
接口的类不能实现jdk
的动态代理;
2. CGlib动态代理(通过继承实现)
- 针对类实现代理;
- 对指定目标类产生一个子类,通过方法拦截技术拦截所有父类方法的调用。(其实就是覆写父类的方法,可见
final
修饰的类都不可能实现GCLIB
代理)
4.3 Hibernate
4.3.1 Hibernate执行过程
- 应用程序先调用
Configuration
类,该类读取Hibernate
配置文件(链接数据库)及映射文件(java
对象个数据库表中对象的一一映射)中的信息;- 并用这些信息生成一个
SessionFactory
对象;- 然后从
SessionFactory
对象生成一个Session
对象;- 并用
Session
对象生成Transaction
对象;
4.3.2 Hibernate一级缓存与二级缓存之间的区别(比较mybatis的一二级缓存)
hibernate
的session
提供了一级缓存的功能,默认总是有效的,当应用程序保持持久化实体,修改持久化实体时,session
并不会立即把这种改变提交到数据库,而是缓存在当前的session
中,除非显示调用了session
的flush()
方法或通过close()
方法关闭session
。通过一级缓存,可以减少程序与数据库的交互,从而提高数据库访问的性能。sessionFactory
级别的二级缓存是全局性的,所有的session
可以共享这个二级缓存。不过二级缓存默认是关闭的,需要显示开启并指定需要使用哪种二级缓存实现类(可以使用第三方提供的实现)。一旦开启了二级缓存并设置了需要使用二级缓存的实体类,sessionFactory
就会缓存访问过的该实体类的每个对象,除非缓存的数据超出了指定的缓存空间。
4.3.3 Hibernate 常见优化策略
- 采用合理的缓存策略(二级缓存、查询缓存);
- 采用合理的
session
管理机制;- 尽量使用延迟加载特性(
mybatis
的延迟加载);- 设定合理的批处理参数;
- 如果可以,选用
UUID
作为主键生成器;- 如果可以,选用基于版本号的乐观锁代替悲观锁;
- 在开发过程中,开启
Hibernate_show_sql
选项查看生成的sql,从而了解低层的状况;开发完成后关闭此选项;- 考虑数据库本身的优化,合理的索引,恰当的数据分区策略等都会对持久层的性能带来可观的提升,但是这些需要专业的
DBA
(数据库管理员)提供支持。
4.3.4 hibernate中 get 和 load 的区别(涉及到一个懒加载问题也就是延迟加载)
get
和load
方法是根据id
去获得对应数据。区别如下:
- 执行
get()
方法时就发送sql语句(不支持延迟加载),并且查询的数据存在内存中,在数据库中查不到记录时不会抛出异常,返回一个null
。hibernate
在查询数据的时候(数据在内存或缓存中,就不需要在从数据库中查询了),数据并不存在内存中而是通过cglib
动态产生的一个代理对象,只有对数据进行操作的时候,才加载到内存中,实现了延迟加载,节省了内存开销,提高服务器性能。用到数据时再发sql语句,在数据库中查不到记录会抛异常。
4.3.5 实体对象生命周期
1. translent
(瞬时态)
实体对象在内存中的存在,与数据库中的记录无关,通过session
的save()
或saveOrUpdate
()方法变成持久态;
2. Persisent
(持久态)
该状态下的实体对象与数据库中的数据保持一致;
3. Detached
(托管状态)
操作托管态的数据不能影响到数据库的修改;
五、SSM(Springmvc + spring + mybatis)
5.1 SpringMVC 实现原理
Springmvc
工作流程:(面试的时候一定要会画Springmvc
的运行图,结合图讲比较好)
- 用户发起请求到前端控制器DispatcherServlet;
- 前端控制器请求处理器映射器HandlerMapping查找
Handler
(通过xml或注解方式查找);- 处理器映射器HandlerMapping向前端控制器返回Handler;
- 前端控制器调用处理器适配器HadlerAdapter去执行Handler;
- 处理器适配器去执行Handler ;
- Handler执行完成给适配器返回ModelAndView;
- 处理器适配器向前端控制器返回ModelAndView;
- 前端控制器请求视图解析器去进行视图解析(将逻辑视图转化成完整的视图地址);
- 然后进行视图渲染填充到request域展现给用户;
5.2 mybatis 实现原理
- 应用程序到
mybatis
的全局配置文件sqlMapConfig.xml
读取配置信息(如:别名设定、包、全局变量定义、mapper扫描(把mapper.xml
和mapper.java
放在同一个目录下,就不需要配置了))- 然后创建会话工厂(链接数据库);
- 通过会话工厂打开会话,dao层和数据库就实现了通道;
- 通过类的反射加载类的实例,然后就可实现对数据的操作;
六、两大框架对比
6.1 SSH 与 Spring+SpringMVC+mybatis 的区别
Spring+SpringMVC+Mybatis
是以spring
为主体,实现了springmvc
与spring
的无缝连接,在层次处理上比SSH
更具优势。- 两者都是基于
ORM
框架;Hibernate
的ORM
实现POJO
和数据库表之间的映射,以及sql
自动生成和执行;Mybatis
着力点在于POJO
与sql
之间的映射关系(主要是输入输出映射)。然后通过映射配置文件。将sql
所需的参数,以及返回的结果字段映射到指定POJO
。
Mybatis
优势:
- 可以进行更为细致的
sql
优化,可以减少查询字段;Mybatis
较Hibernate
容易掌握;
Hibernate
优势:
Hibernate
的DAO
层开发比mybatis
简单,因为mybatis
需要维护sql
和结果映射;hibernate
对对象的维护和缓存比mybatis
好,对增删改查的对象维护也方便。hibernate
数据库移植性要比mybatis
好,因为mybatis
对不同的数据库要写不同的sql
语句;hibernate
有更好的二级缓存机制,还可以使用第三方缓存。Mybatis
本身提供的缓存机制不佳。
最后
小编的一位同事在校期间连续三年参加ACM-ICPC竞赛。从参赛开始,原计划每天刷一道算法题,实际上每天有时候不止一题,一年最终完成了 600+:
凭借三年刷题经验,他在校招中很快拿到了各大公司的offer。
入职前,他把他的刷题经验总结成1121页PDF书籍,作为礼物赠送给他的学弟学妹,希望同学们都能在最短时间内掌握校招常见的算法及解题思路。
整本书,我仔细看了一遍,作者非常细心地将常见核心算法题和汇总题拆分为4个章节。
而对于有时间的同学,作者还给出了他结合众多数据结构算法书籍,挑选出的一千多道题的解题思路和方法,以供有需要的同学慢慢研究。