小白的spring入门笔记

前情回顾

• struts：web层，比较简单（ValueStack值栈，拦截器）
• hibernate：dao层，知识点杂
• spring：service层

基础（IOC(控制反转)，DI（依赖注入））

Spring框架概述

什么是Spring

• Spring框架是一个开放源应用程序框架，是针对bean的生命周期进行管理的轻量级容器（lightweight container）。 Spring解决了开发者在J2EE开发中遇到的许多常见的问题，提供了功能强大IOC、AOP及Web MVC等功能。Spring可以单独应用于构筑应用程序，也可以和Struts、Webwork、Tapestry等众多Web框架组合使用，并且可以与 Swing等桌面应用程序AP组合。因此， Spring不仅仅能应用于JEE应用程序之中，也可以应用于桌面应用程序以及小应用程序之中。Spring框架主要由七部分组成，分别是 Spring Core、 Spring AOP、 Spring ORM、 Spring DAO、Spring Context、 Spring Web和 Spring Web MVC。
• 轻量级：与EJB对比，依赖资源少，销毁的资源少。
• 分层
  • web层：struts，spring-MVC
  • service层：spring
  • dao层：hibernate，mybatis，jdbcTemplate

spring核心

Spring的核心是___控制反转__（IOC）和__面向切面__（AOP）

spring优点

• 方便解耦，简化开发（高内聚，低耦合）
  • spring就是工厂（容器）
  • 用于生成bean
• AOP编程的支持
• 声明式事务的支持
• 方便程序的测试
• 方便集成各种优秀框架
• 降低JavaEEAPI的使用难度

spring体系结构

Beans:管理bean
Core：核心
Context：上下文（配置文件）
Expression：spel表达式

AOP：切面编程
Aspects：AOP框架

JDBC：JdbcTemplete，数据库开发
ORM：整合hibernate
Transactions：事务管理
Web：web开发
Struts：整合struts

Test：整合Junit

IOC入门，控制反转

构建maven依赖

        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-coreartifactId>
            <version>4.3.7.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-beansartifactId>
            <version>4.3.7.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-contextartifactId>
            <version>4.3.7.RELEASEversion>
        dependency>

        
        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-jdbcartifactId>
            <version>4.3.7.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-txartifactId>
            <version>4.3.7.RELEASEversion>
        dependency>

        
        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-webartifactId>
            <version>4.3.7.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-webmvcartifactId>
            <version>4.3.7.RELEASEversion>
        dependency>

        
        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-testartifactId>
            <version>4.3.7.RELEASEversion>
        dependency>

目标类

• 之前开发中，直接new一个对象即可
• 学习spring之后，将由spring创建对象实例->IOC 控制反转，之后需要实例化对象时，从spring工厂（容器）中获得，需要将实现类的全限定名称配置到xml文件中

public class HelloWord {
   
    public void hello(){
   
        System.out.println("Hello Spring");
    }
}

配置文件

• 位置：任意
• 名称：任意，常用：appliactionContext.xml
• 内容：添加schema约束

<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.xsd">
    <bean id="helloWord" class="test.HelloWord"/>
beans>

测试

public class TestIOC {
   
    @Test
    public void demo01() {
   
//        之前
        HelloWord helloWord=new HelloWord();
        helloWord.hello();
//        现在从spring容器获得
//        1：获得容器
//        2：获得内容--不需要自己new，都是从spring容器获得
        ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContent.xml");
        HelloWord helloWord1= (HelloWord) ctx.getBean("helloWord");
        helloWord1.hello();
    }

结果

都可以输出Hello Spring

DI入门，依赖注入

is a :是一个，继承
has a:有一个，成员变量，依赖

		class B{
			private A a; //B类依赖A类
	}

依赖：一个对象需要使用另一个对象
注入：通过setter方法进行另一个对象实例设置

	class BookServiceImpl{
	//	之前开发：接口=实现类（service和dao耦合）
			pirvate BookDao bookDao=new BookDaoImpl();
	//spring之后（解耦，service实现类使用dao的接口，不知道具体的实现类）
			private BookDao bookDao();
			setter();
		}

模拟spring执行过程：
创建service实例：BookService bookService=new BookServiceImpl()；–>IOC
创建dao实例：BookDao bookDao=new BookDaoImpl()； -->IOC
将dao设置给service：bookService.setBookDao(bookDao); -->DI

dao

public interface BookDao {
   
    public void addBook();
}

public class BookDaoImpl implements BookDao {
   
    @Override
    public void addBook() {
   
     System.out.println("添加书籍");
    }
}

service

public interface BookService {
   
    public void addBook();
}

public class BookServiceImpl implements BookService {
   
    //    方式一：
//    BookDao bookDao = new BookDaoImpl();

    //    方式二：
    private BookDao bookDao;

    public void setBookDao(BookDao bookDao) {
   
        this.bookDao = bookDao;
    }

    @Override
    public void addBook() {
   
        this.bookDao.addBook();
    }
}

配置文件

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
    
    
    
    <bean id="bookService" class="service.BookServiceImpl">
        
        
        
        <property name="bookDao" ref="bookDao"/>
    bean>
    <bean id="bookDao" class="dao.BookDaoImpl"/>
beans>

测试

public class test {
   
    @Test
    public void test() {
   
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContent.xml");
        BookService bookService = (BookService) applicationContext.getBean("bookService");
        bookService.addBook();
    }
}

结果

核心API

• BeanFactory：工厂，生产任意bean（采用延迟加载，第一次getBean时才会初始化Bean）
• ApplicationContext：是BeanFactory的子接口，功能更强大（国际化，事件传递，Bean自动装配，各种不同应用层的Context实现），当配置文件被加载，就进行对象实例化。
• ClassPathXmlApplicationContext：用于加载xml
• FileSystemXmlApplicationContext：用于加载指定盘符下的xml

装配Bean基于XML

实例化方式

• 默认构造

 <bean id="bookService" class="service.BookServiceImpl">//必须提供默认工厂

---

• 静态工厂
  • 常用与spring整合其他框架（工具）
  • 静态工厂：用于生成实例对象，所有的方法必须是__static__

<bean id="" class="工厂全限定类名" factory-method="静态工厂方法">

工厂

public class MyBeanFactory {
   
    public static UserService createService() {
   
        return new UserServiceImpl();
    }
}

spring配置

 <bean id="myBeanFactory" class="test.MyBeanFactory" factory-method="createService"/>

静态工厂测试

    @Test
    public void test02() {
   
   //自定义静态工厂
        UserService userService = MyBeanFactory.createService();
        userService.addUser();
  		//spring工厂
         //    class 确定静态工厂全限定类名
		//    factory-method 确定静态方法名
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContent.xml");
        UserService userService1 = (UserService) applicationContext.getBean("myBeanFactory",UserService.class);
        userService1.addUser();
    }

结果：控制台输出add user

---

• 实例工厂
  • 必须先有工厂实例对象，通过实例对象创建对象。提供所有的方法都是__非静态__的
    工厂类

public class MyBeanFactory {
   
public UserService createService() {
   
        return new UserServiceImpl();
    }
}

spring配置

<bean id="myBeanFactory" class="test.MyBeanFactory"/>
    <bean id="userService" factory-bean="myBeanFactory" factory-method="createService"/>

工厂测试

  @Test
    public void test03() {
   
        //自定义实例工厂
        MyBeanFactory myBeanFactory = new MyBeanFactory();
        UserService userService = myBeanFactory.createService();
        userService.addUser();
//        spring实例工厂
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContent.xml");
        UserService userService1 = applicationContext.getBean("userService", UserService.class);
        userService1.addUser();
    }

Bean种类

• 普通bean：之前操作的都是普通bean。，spring直接创建A实例，并返回
• FactoryBean：是一个特殊的bean，具有工厂生成对象能力，只能生成特定的对象。
  • bean必须实现FactoryBean接口，此接口提供方法getObject（）用于获得特定bean。
  • 先创建FB实例，使用调用getObject（）方法，并返回方法的返回值
  • FB fb=bew FB();return fb.getObject();
• BeanFactory和FactoryBean对比？
  • BeanFactory：工厂，用于生成任意bean
  • FactoryBean：特殊bean，用于生成另一个特定的bean：例如：ProxyFactoryBean，此工厂bean用于生产代理的。获得代理对象实例，AOP使用

作用域

用于确定spring创建实例的个数

• 取值
  • singleton ：单例，默认值
  • prototype：每执行一次getBean将获得一个实例。例如：struts整合spring,配置action多例。
• 配置信息

<bean id="" class="" scope="">

测试

 <bean id="userService" class="service.UserServiceImpl" scope="singleton"/>

<bean id="userService" class="service.UserServiceImpl" scope="prototype"/>

生命周期

• 初始化（准备数据）和销毁（清理资源）

目标方法执行前和执行后，将进行初始化或者销毁

<bean id="" class="" init-method="初始化方法名称" destory-method="销毁的方法名称">

初始化

 <bean id="userService" class="service.UserServiceImpl"  init-method="myInit"/>

销毁（容器必须close，销毁方法才能执行，并且必须是单例的）

applicationContext.close();

• BeanPostProcessor 后处理Bean

spring提供一种机制，只要实现此接口BeanPostProcessor，并将实现类提供给spring容器，spring容器将自动执行，在初始化方法前执行before()，在初始化方法后执行after()。
Spring提供的工厂钩子，用于修改实例对象，可以生成代理对象，是AOP底层。

模拟：
A a=new A();
a=B.before(); -->将a的实例对象传递后处理bean，可以生成代理对象并返回
a.init();
a=B.after();
a.addUser(); -->生成代理对象，目的在目标方法前后执行（例如：开启事务，提交事务）
a.destory();

后处理bean

public class myBeanPostProcessor implements BeanPostProcessor {
   
    @Override
    public Object postProcessBeforeInitialization(Object o, String s) throws BeansException {
   
//        return null;//之后使用会出现空指针异常NullPointerException
        return o;
    }

    @Override
    public Object postProcessAfterInitialization(Object o, String s) throws BeansException {
   
        //生成代理
        return Proxy.newProxyInstance(myBeanPostProcessor.class.getClassLoader(), o.getClass().getInterfaces(), new InvocationHandler() {
   
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   
                System.out.println("开启事务");
                Object obj = method.invoke(o