Spring基础

Spring是一个轻量级的DI(Ioc)和AOP的容器框架

 

Spring通过一种称作控制反转（IoC）的技术促进了低耦合

 

AOP：切面编程将业务逻辑从应用服务中分离

 

容器：包含并管理应用对象的生命周期和配置

 

框架：使用组件配置组合成复杂的应用，并提供很多基础功能

并贯穿表现层、业务层及持久层

1.1. Spring核心与模块化

IOC(Inverse of control):控制反转 （Rod Johnson）

    以前service需要一个dao,需要自己去控制整dao的生命周期(自己创建，销毁等)，但是现在service依赖于dao,但是它不负责去管理这个dao的生命周期(不是自己创建,销毁)。相于把以前自己对dao的控制权反转到了容器中(Spring)—以前自己需要new对象，但是现在自己不new了，交给spring的管理了

 DI(Dependence inject):依赖注入

依赖关系由容器注入

对象的关系由容器注入，由容器管理，对象自己不需要管理

AOP(面向切面编程)

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

可以用于：日志记录，性能统计，安全控制，事务处理，异常处理等等

Spring所有的其它功能都是基于容器。 如它帮我们写Hibernate的事务等模板代码，我们总得把Hibernate交给它管理吧

 

1.1. 什么是BeanFactory

Spring是一个容器，它会根据配置为咱们创建相应的bean(对象)。

spring使用BeanFactory来实例化、配置和管理对象，但是它只是一个接口，里面有一个getBean()方法。

1. BeanFactory是Spring的一个核心接口
2. BeanFactory的主要作用是拿到实例化，配置与管理Bean对象
3. BeanFactory拿Spring有三种方式(id,类型,id与类型,class实例)
4. 扩展BeanFactory的常用方法(看下图)

1. ApplicationContext

ApplicationContext的中文意思是“应用前后关系”，它继承自BeanFactory接口，除了包含BeanFactory的所有功能之外，在国际化支持、资源访问（如URL和文件）、事件传播等方面进行了良好的支持，被推荐为Java EE应用之首选，可应用在Java APP与Java Web中。

 

应用上下文ApplicationContext是建立在BeanFactory基础上的一种更高层次的Spring IoC容器，其除了具有普通BeanFactory的全部功能以外，还加入了以下功能：

 

提供了文本信息解析工具，包括I18N的支持

 

提供了载入文件资源的通用方法

 

提供了发送事件的功能

/拿到核心对象 ApplicationContext

//注：后面的对象是从 classpath根路径开始的

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

MyBean bean = (MyBean) context.getBean("myBean");

 

面试题：ApplicationContext与BeanFactory的区别

解释：ApplicationContext是BeanFactory的子类,拥有更多的功能与方法

重点：ApplicationContext对bean是在读取的时候就创建Bean对象，而BeanFactory是在使用的时候才进行对象的创建(懒加载)

扩展：我们在使用ApplicationContext的时候，可以通过配置让它也变成与BeanFactory一样的懒加载：

配置一：让所有Bean都变成懒加载

① 这句代码已经创建Bean（ApplicationContext及时加载）

ClassPathXmlApplicationContext context =

      new ClassPathXmlApplicationContext("applicationContext.xml"); 

② 下面这句还没有创建（BeanFactory懒加载） 使用的时候才加载

//读取资源文件

ClassPathResource resource = new ClassPathResource("applicationContext.xml");

//创建BeanFactory

BeanFactory beanFactory = new XmlBeanFactory(resource);

          UserDao userDao1 = (UserDao)beanFactory.getBean("userDao");//需要的加载

<beans xmlns="http://www.springframework.org/schema/beans"

....

default-lazy-init="true">

<bean id="myBean" class="cn.itsource._01_hello.MyBean"></bean>

</beans>

 

配置二：让其中一个Bean变成懒加载

<bean id="myBean" class="cn.itsource._01_hello.MyBean" lazy-init="true"></bean>

1.1.1. 什么是Spring测试

咱们讲的Spring测试主要是讲SpringJunit，这个Spring自己专门写的一套测试框架功能。 (注：Spring的测试是基于junit测试的，如下图)

 

传统Spring测试：用测试去管理spring  ，每个方法 都需要启动spring，麻烦。

 

使用Spring框架测试(由Spring来接管测试功能)—先启动Spring，在启动junit，支持注解

1.1.1. Spring测试的作用

因为三大框架整合的时候如果Spring的配置文件不能读取，那么整个项目是跑不起来的， 而Spring的测试可以让我们在不启动服务器的情况下，就把相应的项目跑起来。

可以在不启动服务器的情况下，自动读取相应的配置文件。

@RunWith：表示先启动Spring容器，把junit运行在Spring容器中；

@ContextConfiguration("classpath:applicationContext.xml")：

表示从CLASSPATH路径去加载资源文件；

@Autowired：表示自动装配，自动从Spring容器中取出对应bean或者获取容器对象；

 

动态代理（以下称代理），利用Java的反射技术(Java Reflection)，在运行时创建一个实现某些给定接口的新类（也称“动态代理类”）及其实例（对象）

(Using Java Reflection to create dynamic implementations of interfaces at runtime)。

代理的是接口(Interfaces)，不是类(Class)，更不是抽象类。

动态代理有什么用

解决特定问题：一个接口的实现在编译时无法知道，需要在运行时才能实现

实现某些设计模式：适配器(Adapter)或修饰器(Decorator)

面向切面编程：如AOP in Spring

 

Bean节点有个属性scope

 

singleton,默认值,单例

 

prototype,多例  struts2的action必须配置多例：

 

 

<bean id="scopeBean" class="cn.itsource._03_scope.MyScopeBean" scope="prototype"></bean>

 

一般都不用

 

request 放到http请求作用域 ，每次请求 都会产生新的bean

 

session 放到http会话作用域，每次会话  都会产生新的bean

 

Bean对象的生命周期

生命周期：构造 （创建）-> 初始化->运行-> 销毁   

bean创建之后 就直接初始化 ，初始化运行之后，就销毁

配置多例的情况下，不会执行销毁（手动回收）

 

 

三层构架介绍

 

三层架构咱们前面都已经给大家讲解过，咱们开发把整个操作分成三层：

 

 

表现层(Web,GUI,...) 现在咱们做的jsp/servlet(struts2)就是开发表现层

 

业务层(service) 处理相应的业务，由表现层调用，现在咱们还未加上

 

持久层(dao) 做数据的持久化(现在咱们操作数据库就是完成持久化的功能)

 

JDBC，SpringJDBC,Hibernate,MyBatis

 完成第一个Spring

 第一步：导包

spring-framework-4.1.2.RELEASE

注入功能

9.1普通类注入

模拟使用Spring 操作 Action->Service->DAO 的过程

在使用Spring的过程中，我们需要修改过去自己的写法。 以前的对象都是自己来创建，现在，所有的对象的创建都应该交给Spring来处理。

现在，我们先模拟完成过去的从Action向下调用的过程。再将它们改为现在使用Spring后的过程。  这里涉及到了咱们的一个思维的转变(即将创建交给Spring)。

public class UserDao {
    public void save(){
        System.out.println("保存用户....");
    }
}


public class UserService {
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    

public void save(){
        userDao.save();
    }
}


public class UserAction {
    private UserService userService;
    public void setUserService(UserService userService) {
        this.userService = userService;
    }
    public void save(){
        userService.save();
    }
}
准备好配置文件
<bean id="userDao" class="cn.itsource._04_ioc.UserDao"></bean>
<bean id="userService" class="cn.itsource._04_ioc.UserService">
    <!-- 
        这里就是完成 类对象的属性注入
            name -> 类中的属性名称(setName)
            ref -> 引用的哪一个Bean的id
     -->
    <property name="userDao" ref="userDao"></property>
</bean>
<bean id="userAction" class="cn.itsource._04_ioc.UserAction">
    <property name="userService" ref="userService"></property>
</bean>

准备测试代码
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class IOCTest {
    @Autowired
    UserAction userAction;
    @Test
    public void testBegin() throws Exception {
        userAction.save();
    }
}

<!-- 配置一个DBCP的Bean -->

<bean name="dateSource" class="org.apache.commons.dbcp.BasicDataSource"

destroy-method="close">

<!-- 注意：这里我们不是使用的ref引用，而是直接写的value，因此注入的数据是一个变通的值 -->

<property name="driverClassName" value="com.mysql.jdbc.Driver" />

<property name="url" value="jdbc:mysql:///test" />

<property name="username" value="root" />

<property name="password" value="admin" />

</bean>