Spring 学习笔记

至尊灬雷

好影象没有如烂笔头, 能记下面甚么, 便记下面甚么, 便利前期的稳固
Spring引见

Spring 是一个开源框架，是一个分层的 JavaEE 一站式框架。
所谓一站式框架是指 Spring 有 JavaEE 开辟的每层处理计划。

• WEB层：SpringMVC
  
• Service层：Spring的Bean办理，声明式事件
  
• DAO层：Spring的JDBC模板，ORM模板
  

长处：

• IOC：便利解耦开
  
• AOP：对程序停止扩大
  
• 沉量级框架
  
• 便利取其他框架整开
  

Spring利用

Spring开辟包解压后的目次引见：

• docs: Spring 开辟标准战API
  
• libs: Spring jar 包战源代码
  
• schema: Spring 设置文件的束缚
  

 
DataAccess 用于数据会见，WEB 用于页里显现，中心容器也便是IOC部门。
 
掌握反转（IOC）

掌握反转（Inversion of Control）是指将工具的创立权反转（交给）Spring。
利用IOC便需求导进IOC相干的包，也便是上图中中心容器中的几个包：beans,context,core,expression四个包。
 
完成道理

传统方法创立工具：
UserDAO userDAO=new UserDAO();
进一步里背接心编程，能够多态：
UserDAO userDAO=new UserDAOImpl();
这类方法的缺陷是接心战完成类下耦开，切换底层完成类时，需求修正源代码。程序设想该当满意OCP元祖，正在只管没有修正程序源代码的根柢上对程序停止扩大。此时，可使用工场形式：
class BeanFactory{
    public static UserDAO getUserDAO(){
        return new UserDAOImpl();
    }
}
此种方法固然正在接心战完成类之间出有耦开，可是接心战工场之间存正在耦开。
利用工场+反射+设置文件的方法，完成解耦，那也是 Spring 框架 IOC 的底层完成。
//xml设置文件
//
class BeanFactory{
    public static Object getBean(String id){
        //剖析XML
        //反射
        Class clazz=Class.forName();
        return clazz.newInstance();
    }
}
IOC XML 开辟

正在 docs 文件中包罗了 xsd-configuration.hmtl 文件。此中界说了 beans schema。

    //正在此设置bean
   
   

挪用类：
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService=(UserService)applicationContext.getBean("userService");
userService.save();
IOC 战 DI
DI 指依靠注进，其条件是必需有 IOC 的状况，Spring 办理那个类的时分将类的依靠的属性注进出去。
例如，正在UserServiceImpl.java中：
public class UserServiceImpl implements UserService{
private String name;
public void setName(String name){
this.name=name;
}
public void save(){
System.out.println("save "+name);
}
}
正在设置文件中：

   
   
    
   

测试代码：
@Test
public void demo2(){
//创立Spring工场
ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService=(UserService)applicationContext.getBean("userService");
userService.save();
}
运转成果：
save tony
能够看到，正在设置文件中设置的属性，正在 Spring 办理该类的时分将其依靠的属性胜利停止了设置。假如没有利用依靠注进，则没法利用接心，只能利用完成类去停止设置，由于接心中出有该属性。
Spring 的工场类

• BeanFactory: 老版本的工场类，正在挪用getBean()办法时，才会天生类的真例。
  
• ApplicationContext: 正在减载设置文件的时分，便会将 Spring 办理的类皆真例化。有两个完成类：
  
  
  
  • ClassPathXmlApplicationContext: 减载类途径下的设置文件
    
  • FileSystemXmlApplicationContext: 减载磁盘下的设置文件
    
  
  

bean标签设置

• id: 独一束缚，不克不及呈现特别字符
  
• name: 实际上能够反复，可是开辟中最好没有要。能够呈现特别字符
  

性命周期：

• init-method: bean被初初化的时分施行的办法
  
• destroy-method: bean被烧毁的时分施行的办法
  

感化范畴：

• scope： bean的感化范畴，有以下几种，经常使用的是前两种
  
  
  
  • singleton: 默许利用单例形式创立
    
  • prototype: 多例
    
  • request: 正在web项目中，spring 创立类后，将其存进到 request 范畴中
    
  • session: 正在web项目中，spring 创立类后，将其存进到 session 范畴中
    
  • globalsession: 正在web项目中，必需用正在 porlet 状况
    
  
  

属性注进设置

• 机关办法方法的属性注进： Car 类正在机关办法中有两个属性，别离为 name 战 price。
  

   
   

• set 办法属性注进： Employee 类正在有两个 set 办法，别离设置一般范例的 name 战援用范例的 Car （利用 ref 指背援用范例的 id 或  name）。
  

   
   

• P称号空间的属性注进： 起首需求引进p称号空间：
  

假如是一般属性：


假如是援用范例：

• SpEL(Spring Expression Language)属性注进（Spring 3.x以上版本）
  

   
   

• 汇合范例属性注进：
  

   
       
            qirui
            baoma
            benchi
       
   

多模块开辟设置

• 正在减载设置文件的时分，减载多个设置文件
  
• 正在一个设置文件中引进多个设置文件，经由过程完成
  

IOC 注解开辟

示例

• 引进jar包： 除要引进上述的四个包以外，借需求引进aop包。
  
• 创立 applicationContext.xml ，利用注解开辟引进 context 束缚（xsd-configuration.html）
  

 
       

• 组件扫描： 利用IOC注解开辟，需求设置组件扫描，也便是哪些包下的类利用IOC的注解。
  

• 正在类上增加注解
  
• 利用注解设置属性的值
  

属性假如有set办法，将属性注进的注解增加到set办法
属性出有set办法，将注解增加到属性上。
@Component("UserDao")//相称于设置了一个 其id为UserDao,对应的类为该类
public class UserDAOImpl implements UserDAO {
@Override
public void save() {
// TODO Auto-generated method stub
System.out.println("save");
} 
}
注解详解

• @Component
  

组件注解，用于润饰一个类，将那个类交给 Spring 办理。
有三个衍死的注解，功用相似，也用去润饰类。

• @Controller：润饰 web 层类
  
• @Service：润饰 service 层类
  
• @Repository：润饰 dao 层类
  

2.属性注进

• 一般属性利用 @Value 去设置属性的值
  
• 工具属性利用 @Autowired  ，那个注解是根据范例去停止属性注进的。假如期望根据 bean 的称号或id停止属性注进，需求用 @Autowired 战 @Qualifier 一同利用
  
• 实践开辟中，利用 @Resource(name=" ") 去停止根据工具的称号完成属性注进
  

3.其他注解

• @PostConstruct 相称于 init-method，用于初初化函数的注解
  
• @PreDestroy 相称于 destroy-method，用于烧毁函数的注解
  
• @Scope 感化范畴的注解，经常使用的是默许单例，另有多例 @Scope("prototype")
  

IOC 的 XML 战注解开辟比较

• 合用场景：XML 合用于任何场景；注解只合适本人写的类，没有是本人供给的类没法增加注解。
  
• 可使用 XML 办理 bean，利用注解去停止属性注进
  

AOP开辟

AOP 是 Aspect Oriented Programming 的缩写，意为里背切里编程，经由过程预编译方法战运转期静态代办署理完成程序功用的同一保护的一种手艺，是OOP的持续。
AOP 可以对程序停止加强，正在没有修正源码的状况下，能够停止权限校验，日记记载，机能监控，事件掌握等。
也便是道功用分为两年夜类，一类是中心营业功用，一类是帮助加强功用。两类功用相互自力停止开辟。好比登录功用是中心营业功用，日记功用是帮助加强功用，假如有需求，将日记战登录体例正在一同。帮助功用便称为切里，这类能挑选性的、低耦开的把切里战中心营业功用分离的编程思惟称为切里编程。
底层完成
JDK 静态代办署理只能对完成了接心的类发生代办署理。Cglib 静态代办署理能够对出有完成接心的类发生代办署理工具，天生的是子类工具。
利用 JDK 静态代办署理：
public interface UserDao {
public void insert();
public void delete();
public void update();
public void query();
}
完成类：
public class UserDaoImpl implements UserDao { @Override public void insert() { System.out.println("insert"); } @Override public void delete() { System.out.println("delete"); } @Override public void update() { System.out.println("update"); } @Override public void query() { System.out.println("query"); } }
JDK 代办署理：
public class JDKProxy implements InvocationHandler{
private UserDao userDao;
public JDKProxy(UserDao userDao){
this.userDao=userDao;
}
public UserDao createProxy(){
UserDao userDaoProxy=(UserDao)Proxy.newProxyInstance(userDao.getClass().getClassLoader(),
userDao.getClass().getInterfaces(), this);
return userDaoProxy;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if("update".equals(method.getName())){
System.out.println("权限校验");
return method.invoke(userDao, args);
}
return method.invoke(userDao, args);
}
}
经由过程静态代办署理加强了 update 函数。 测试类：
public class Demo1 {
@Test
public void demo1(){
UserDao userDao=new UserDaoImpl();
UserDao proxy=new JDKProxy(userDao).createProxy();
proxy.insert();
proxy.delete();
proxy.update();
proxy.query();
}
}
运转成果为：
insert
delete
权限校验
update
query
CglibCglib 是第三圆开源代码天生类库，能够静态增加类的属性战办法。
取上边JDK代办署理差别，Cglib的利用方法以下：
public class CglibProxy implements MethodInterceptor{
//传进加强的工具
private UserDao customerDao;
public CglibProxy(UserDao userDao){
this.userDao=userDao;
}
public UserDao createProxy(){
Enhancer enhancer=new Enhancer();
enhancer.setSuperclass(userDao.getClass());
enhancer.setCallback(this);
UserDao proxy=(UserDao)enhancer.create();
return proxy;
}
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
if("save".equals(method.getName())){
System.out.println("enhance function");
return methodProxy.invokeSuper(proxy, args);
}
return methodProxy.invokeSuper(proxy, args);
}
}
假如完成了接心的类，底层采取JDK代办署理。假如没有是完成了接心的类，底层采取 Cglib代办署理。
IOC取传统方法的比较

• 获得工具方法：传统经由过程 new 枢纽字自动创立一个工具。IOC 方法中，将工具的性命周期交给 Spring 办理，间接从 Spring 获得工具。也便是掌握反转————将掌握权从本人脚中交到了 Spring 脚中。
  

Spring 的 AOP 开辟（AspectJ 的 XML 方法）

AspectJ 是一个 AOP 的框架，Spring 引进 AspectJ，基于 AspectJ 停止 AOP 的开辟。
相干术语

• Joinpoint: 毗连面，能够被阻拦到的面。也便是能够被加强的办法皆是毗连面。
  
• Pointcut: 切进面，实正被阻拦到的面，也便是实正被加强的办法
  
• Advice: 告诉，办法层里的加强。对某个办法停止加强的办法，好比对 save 办法停止权限校验，权限校验的办法称为告诉。
  
• Introduction: 引介，类层里的加强。
  
• Target: 目的，被加强的工具（类）。
  
• Weaving: 织进，将 advice 使用到 target 的历程。
  
• Proxy: 代办署理工具，被加强的工具。
  
• Aspect: 切里，多个告诉战多个切进面的组开。
  

利用办法

• 引进相干包
  
• 引进设置文件
  

  

• 编写目的类并设置：
  

public class ProductDaoImpl implements ProductDao {
@Override
public void save() {
System.out.println("save");
}
@Override
public void update() {
System.out.println("update");
}
@Override
public void find() {
System.out.println("find");
}
@Override
public void delete() {
System.out.println("delete");
}
}

• 编写切里类，假定用于权限考证并设置
  

public class MyAspectXML {
public void checkPri(){
System.out.println("check auth");
}
}

• 经由过程AOP设置完成对目的类的加强
  

 

 
告诉范例

• 前置告诉：正在目的办法施行前操作，能够得到切进面疑息
  

public void checkPri(JoinPoint joinPoint){
System.out.println("check auth "+joinPoint);
}

• 后置告诉：正在目的办法施行后操作，能够得到办法返回值
  

public void writeLog(Object result){
    System.out.println("writeLog "+result);
}

• 环抱告诉：正在目的办法施行前战后操作，能够阻遏目的办法执
  

public Object around(ProceedingJoinPoint joinPoint) throws Throwable{
System.out.println("before");
Object result=joinPoint.proceed();
System.out.println("after");
return result;
}

• 非常扔出告诉：程序呈现非常时操作
  

public void afterThrowing(Throwable ex){
System.out.println("exception "+ex.getMessage());
}

• 终极告诉：相称于finally块，不管代码能否有非常，城市施行
  

public void finallyFunc(){
System.out.println("finally");
}

• 引介告诉：没有经常使用
  

Spring 切进面表达式
基于 execution 函数完成
语法：[会见润饰符] 办法返回值 包名.类名.办法名(参数)
此中随便字段可使用*替代暗示随便值
Spring 的 AOP 基于 AspectJ 注解开辟

开辟步调

• 引进jar包
  
• 设置设置文件：
  

• 编写设置目的类
  

public class OrderDao {
public void save(){
System.out.println("save order");
}
public void update(){
System.out.println("update order");
}
public void delete(){
System.out.println("delete order");
}
public void find(){
System.out.println("find order");
}
}

• 开启aop注解主动代办署理
  

• 编写切里类并设置
  

@Aspect
public class MyAspectAnno {
@Before(value="execution(* demo1.OrderDao.save(..))")
public void before(){
System.out.println("before");
}
}

注解告诉范例

• @Before： 前置告诉
  
• @AfterReturning: 后置告诉
  

@AfterReturning(value="execution(* demo1.OrderDao.save(..))",returning="result")
public void after(Object result){
System.out.println("after "+result);
}

• @Around：环抱告诉
  

@Around(value="execution(* demo1.OrderDao.save(..))")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable{
System.out.println("before");
Object obj=joinPoint.proceed();
System.out.println("after");
return obj;
}

• @AfterThrowing: 扔出非常
  

@AfterThrowing(value="execution(* demo1.OrderDao.save(..))",throwing="e")
public void afterThrowing(Throwable e){
System.out.println("exception:"+e.getMessage();
}

• @After: 终极告诉
  

@After(value="execution(* demo1.OrderDao.save(..))")
public void after(){
System.out.println("finally");
}

• @PointCut:切进面注解
  

@PointCut(value="execution(* demo1.OrderDao.save(..))")
private void pointcut1(){}
此时，正在上述告诉的注解中，value能够交换为该函数名，例如：
@After(value="MyAspect.pointcut1()")
public void after(){
System.out.println("finally");
}
那个注解的长处是，只需求保护切进面便可，不用正在修正时修正每一个注解。
Spring 的 JDBC 模板

Spring 对耐久层也供给了解决计划，也便是 ORM 模块战 JDBC 的模板。针对 JDBC ，供给了 org.springframework.jdbc.core.JdbcTemplate 做为模板类。
利用 JDBC 模板

• 引进jar包，数据库驱动，Spring 的 jdbc 相干包。
  
• 底子利用：
  

public void demo1(){
    //创立毗连池
DriverManagerDataSource dataSource=new DriverManagerDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql:///spring4");
dataSource.setUsername("root");
dataSource.setPassword("123456");
//创立JDBC模板 
JdbcTemplate jdbcTemplate=new JdbcTemplate(dataSource);
jdbcTemplate.update("insert into account values (null,?,?)", "xiaoming",1000d);
}

• 将毗连池战模板交给 Spring 办理
  

• 设置文件：
  

 

• 测试文件：
   
  

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class JdbcDemo2 {
@Resource(name="jdbcTemplate")
private JdbcTemplate jdbcTemplate;
@Test
public void demo2(){
jdbcTemplate.update("insert into account values (null,?,?)", "xiaolan",1000d);
}
}
利用开源数据库毗连池

• 利用 DBCP 的设置：
  

• 利用 C3P0 的设置：
  

• 引进内部属性文件
  

起首成立内部属性文件：
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://192.168.66.128/spring4
jdbc.username=root
jdbc.password=123456
然后对属性文件停止设置：







CRUD操作

insert, update, delete 语句皆借助模板的 update 办法停止操作。
public void demo(){
jdbcTemplate.update("insert into account values (null,?,?)", "xiaoda",1000d);
jdbcTemplate.update("update account set name=?,money=? where id=?", "xiaoda",1000d,2);
jdbcTemplate.update("delete from account where id=?", 6);
}
查询操作：
public void demo3(){
String name=jdbcTemplate.queryForObject("select name from account where id=?",String.class,5);
long count=jdbcTemplate.queryForObject("select count(*) from account",Long.class);
}
将返回的成果启拆成为类：
public void demo4(){
Account account=jdbcTemplate.queryForObject("select * from account where id=?", new MyRowMapper(),5);
}
此中：
class MyRowMapper implements RowMapper{
@Override
public Account mapRow(ResultSet rs, int rowNum) throws SQLException {
Account account=new Account();
account.setId(rs.getInt("id"));
account.setName(rs.getString("name"));
account.setMoney(rs.getDouble("money"));
return account;
}
}
Spring的事件办理

事件

事件是指逻辑上的一组操作，构成那组操作的各个单元，要末局部胜利，要末局部失利。
具有四个特征：

• 本子性：事件不成分
  
• 分歧性：事件施行前后数据完好性连结分歧
  
• 断绝性：一个事件的施行不该该遭到其他事件滋扰
  
• 耐久性：一旦事件完毕，数据便耐久化到数据库
  

假如没有思索断绝性会激发宁静性成绩：

• 读成绩：
  
  
  
  • 净读：一个事件读到另外一个事件已提交的数据
    
  • 不成反复读：一个事件读到另外一个事件曾经提交的 update 数据，招致一个事件中屡次查询成果纷歧致
    
  • 幻读：一个事件读到另外一个事件曾经提交的 insert 数据，招致一个事件中屡次查询成果纷歧致
    
  
  
• 写成绩：
  
  
  
  • 丧失更新
    
  
  

处理读成绩：设置事件断绝级别

• Read uncommitted: 已提交读，没法处理任何读成绩
  
• Read committed: 已提交读，处理净读成绩
  
• Repeatable read: 反复读，处理净读战不成反复读成绩
  
• Serializable：序列化，处理一切读成绩
  

事件办理API

• PlatformTransactionManager: 仄台事件办理器
  

那是一个接心，具有多个差别的完成类，如 DataSourceTransactionManager 底层利用了JDBC 办理事件； HibernateTransactionManager 底层利用了 Hibernate 办理事件。

• TransactionDefinition: 事件界说疑息
  

用于界说事件的相干疑息，如断绝级别、超时疑息、传布举动、能否只读等

• TransactionStatus: 事件的形态
  

用于记载正在事件办理过程当中，事件的形态的工具。
上述API的干系： Spring 正在停止事件办理的时分，起首仄台事件办理器按照事件界说疑息停止事件办理，正在事件办理历程傍边，发生各类此形态，将那些形态疑息记载到事件形态的工具傍边。
事件的传布举动

事件的传布举动次要处理营业层（Service）办法互相挪用的成绩，也便是差别的营业中存正在差别的事件时，怎样操作。
Spring 中供给了7种事件的传布举动，分为三类：

• 包管多个操作正在统一个事件中
  
  
  
  • PROPAGATION_REQUIRED: B办法挪用A办法，假如A中有事件，利用A中的事件并将B中的操作包罗到该事件中；不然新建一个事件，将A战B中的操作包罗出去。（默许）
    
  • PROPAGATION_SUPPORTS：假如A中有事件，利用A的事件；不然没有利用事件
    
  • PROPAGATION_MANDATORY：假如A中有事件，利用A的事件；不然扔出非常
    
  
  
• 包管多个操作没有正在统一个事件中
  
  
  
  • PROPAGATION_REQUIRES_NEW：假如A中有事件，将其挂起，创立新事件，只包罗本身操作。不然，新建一个事件，只包罗本身操作。
    
  • PROPAGATION_NOT_SUPPORTED：假如A中有事件，挂起，没有利用事件。
    
  • PROPAGATION_NEVER：假如A中有事件，扔出非常，也即不克不及用事件运转。
    
  
  
• 嵌套事件
  
  
  
  • PROPAGATION_NESTED：假如A有事件，根据A的事件施行，施行完成后，设置一个保存面，然后施行B的操作。假如呈现非常，能够回滚到最后形态或保存面形态。
    
  
  

真例

以转账为例，营业层的DAO层类以下：
public interface AccountDao {
public void outMoney(String from,Double money);
public void inMoney(String to,Double money);
}
public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao{
@Override
public void outMoney(String from, Double money) {
 this.getJdbcTemplate().update("update account set money = money - ? where name = ?",money,from);
}
@Override
public void inMoney(String to, Double money) {
this.getJdbcTemplate().update("update account set money = money + ? where name = ?",money,to);
}
}
public interface AccountService {
public void transfer(String from,String to,Double money);
}
public class AccountServiceImpl implements AccountService {
private AccountDao accountDao;
public void setAccountDao(AccountDao accountDao) {
this.accountDao = accountDao;
}
@Override
public void transfer(String from, String to, Double money) {
accountDao.outMoney(from, money);
accountDao.inMoney(to, money);
}
}
正在xml中停止类的设置：






 
事件办理1: 编程式事件办理

• 设置仄台事件办理器
  

• 设置事件办理模板类
  

• 正在营业层注进事件办理模板
  

• 编码完成事件办理
  

//ServiceImpl类中：
private TransactionTemplate transactionTemplate;
@Override
public void transfer(String from, String to, Double money) {
transactionTemplate.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus arg0) {
accountDao.outMoney(from, money);
accountDao.inMoney(to, money);
}
});
}
声明式事件办理（设置完成，基于AOP思惟）

• XML 方法的声明式事件办理
  

• 设置事件办理器
  

• 设置事件告诉
  

• 设置aop事件
  

• 注解方法
  

• 设置事件办理器，战上圆分歧
  
• 开启事件办理的注解：
  

• 正在利用事件的类上增加一个注解@Transactional
  

 
当前另有的内乱容，再来弥补！
文章地点：https://mp.weixin.qq.com/s?__biz=MzU0NTk2MjQyOA==&mid=2247483971&idx=1&sn=cbfb9895543257282f68c8009db23d14&chksm=fb65a290cc122b86891abfcabb67a9fdffe3cb9b9d97ce6572f1e1f3c772b843da30d49ceedf&mpshare=1&scene=23&srcid=0106VNIBwZLqKJLN4B8PbGXY#rd

免责声明：假如进犯了您的权益，请联络站少，我们会实时删除侵权内乱容，感谢协作！