spring学习笔记

Spring相关API

spring学习笔记
Spring的API体系异常庞大,我们现在只关注两个BeanFactory和ApplicationContext

BeanFactory

BeanFactory是IOC的核心接口,他定义了IOC的基本功能。

ApplicationContext

ApplicationContext代表应用上下文对象 ,可以获得springIOC容器中的Bean对象

ApplicationContext和 BeanFactory 的区别?

//使用ClassPathXmlApplicationContext 获取spring上下文对象,借助上下文对象可以获取到IOC容器中的bean对象,它再加载配置文件的同时就创建了bean对象到容器中
 ApplicationContext applicationContext = new   ClassPathXmlApplicationContext("applicationContext.xml");

//使用上下文对象从IOC容器中获取bean
 IUserDao userDao = (IUserDao) applicationContext .getBean("userDao");


 //核心接口  这一步不会创建bean对象  存到容器中的
BeanFactory xmlBeanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));

//getBean的时候 才正真的创建bean对象
IUserDao userDao = (IUserDao) xmlBeanFactory.getBean("userDao");

从上面代码来说
ApplicationContext 在加载核心配置文件 的时候就去创建了bean对象到容器
BeanFactory 是真正在getBean的时候才去创建bean对象

ApplicationContext常用的实现类

  1. ClassPathXmlApplicationContext 它是从类的根路径下加载配置文件 推荐使用这种。
  2. FileSystemXmlApplicationContext 它是从磁盘路径上加载配置文件,配置文件可以在磁盘的任意位置。
  3. AnnotationConfigApplicationContext 当使用注解配置容器对象时,需要使用此类来创建 spring 容器。它用来读取注解。

常用方法

// 根据Bean的id从容器中获得Bean实例,返回是Object,需要强转。 
Object getBean(String name);

//根据类型从容器中匹配Bean实例,当容器中相同类型的Bean有多个时,则此方法会报错。
<T> T getBean(Class<T> requiredType); 

//根据Bean的id和类型获得Bean实例,解决容器中相同类型Bean有多个情况。 
<T> T getBean(String name,Class<T> requiredType); 

Spring配置文件

Bean标签的基本配置

 <!--
 	bean标签:在spring配置文件中配置 userDaoImpl
    id:Bean实例在spring容器中的唯一标识,使用过程中根据这个id才能在spring中找到我们需要的Bean
    class:Bean的全限定名(spring底层采用反射来生成该类的实例,所以必须要放该类的全限定名)
    -->
<bean id = "唯一标识" class="类的全路径名"></bean>
<!--
	默认情况下它是调用类中的无参构造函数进行对象创建,如果没有无参构造函数则不能创建对象
-->

Bean标签的范围配置

  <bean id="" class="" scope="作用范围"></bean>

scope属性指对象的作用范围,取值如下:

取值范围 说明
singleton 默认值,单例的
prototype 多例的
request WEB项目中,Spring创建一个Bean的对象,将对象存入到request域中
session WEB项目中,Spring创建一个Bean的对象,将对象存入到session域中
global session WEB项目中,应用在Portlet环境,如果没有Portlet环境那么globalSession 相当于 session
 	/**
     * <bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl" scope="singleton" ></bean>
     * 测试 scope为singleton的情况下 bean的创建情况
     */
    @Test
    public void test03(){

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

        //userDao1
        IUserDao userDao1 = (IUserDao) applicationContext.getBean("userDao");
        System.out.println(userDao1);

        //userDao2
        IUserDao userDao2 = (IUserDao) applicationContext.getBean("userDao");
        System.out.println(userDao2);
    }

结果为
spring学习笔记


    /**
     * <bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl" scope="prototype" ></bean>
     * 测试 scope为prototype的情况下 bean的创建情况
     */
    @Test
    public void test04(){

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

        //userDao1
        IUserDao userDao1 = (IUserDao) applicationContext.getBean("userDao");
        System.out.println(userDao1);

        //userDao2
        IUserDao userDao2 = (IUserDao) applicationContext.getBean("userDao");
        System.out.println(userDao2);
    }

结果为
spring学习笔记

1.当scope的取值为singleton时
			Bean的实例化个数:1个
			Bean的实例化时机:当Spring核心文件被加载时,实例化配置的Bean的实例
			Bean的生命周期:
				对象创建:当容器加载,创建容器时,对象就被加载了
				对象运行:只要容器在,对象一直活着
				对象销毁:当应用卸载,销毁容器时,对象就被销毁了

2.当scope的取值为prototype时
			Bean的实例化个数:多个
			Bean的实例化时机:当调用getBean()方法时实例化Bean
			Bean的生命周期:
				对象创建:当使用对象时,对象就被加载了
				对象运行:只要对象在使用中,对象一直活着
				对象销毁:当对象长时间不用时,被Java的垃圾回收器回收

bean声明周期配置

bean id="" class="" scope="" init-method="" destroy-method=""></bean> 

* init-method:指定类中的初始化方法名称 

* destroy-method:指定类中销毁方法名称

Bean实例化三种方式

  • 无参构造方法实例化
  • 工厂静态方法实例化
  • 工厂普通方法实例化

无参构造方法实例化

它会根据默认无参构造方法来创建类对象,如果bean中没有默认无参构造函数,将会创建失败

<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"/>

工厂静态方法实例化

依赖的jar包中有个A类,A类中有个静态方法m1,m1方法的返回值是一个B对象。如果我们频繁使用B对象,此时我们可以将B对象的创建权交给spring的IOC容器,以后我们在使用B对象时,无需调用A类中的m1方法,直接从IOC容器获得。

public class StaticFactoryBean { 

	public static UserDao createUserDao(){ 
		return new UserDaoImpl(); 
	} 
}
<bean id="userDao" class="com.lagou.factory.StaticFactoryBean" factory-method="createUserDao" />

工厂普通方法实例化

依赖的jar包中有个A类,A类中有个普通方法m1,m1方法的返回值是一个B对象。如果我们频繁使用B对象,此时我们可以将B对象的创建权交给spring的IOC容器,以后我们在使用B对象时,无需调用A类中的m1方法,直接从IOC容器获得。

public class DynamicFactoryBean{ 

	public UserDao createUserDao(){ 
		return new UserDaoImpl(); 
	} 
}
<bean id="dynamicFactoryBean" class="com.lagou.factory.DynamicFactoryBean"/> 
<bean id="userDao" factory-bean="dynamicFactoryBean" factory-method="createUserDao"/>

Bean依赖注入概述

依赖注入 DI(Dependency Injection):它是 Spring 框架核心 IOC 的具体实现。
在编写程序时,通过控制反转,把对象的创建交给了 Spring,但是代码中不可能出现没有依赖的情况。IOC 解耦只是降低他们的依赖关系但不会消除。例如:业务层仍会调用持久层的方法。

那这种业务层和持久层的依赖关系,在使用 Spring 之后,就让 Spring 来维护了。简单的说,就是通过框架把持久层对象传入业务层,而不用我们自己去获取。

Bean依赖注入方式

构造方法

public class UserServiceImpl implements UserService { 

private UserDao userDao; 

public UserServiceImpl(UserDao userDao) { 
	this.userDao = userDao; 
}

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

配置Spring容器调用有参构造时进行注入

<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"/> 
<bean id="userService" class="com.lagou.service.impl.UserServiceImpl"> 
<!--<	<constructor-arg index="0" type="com.lagou.dao.UserDao" ref="userDao"/> - ->
	<constructor-arg name="userDao" ref="userDao"/> </bean>

set方法

public class UserServiceImpl implements UserService { 

private UserDao userDao; 

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

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

配置Spring容器调用set方法进行注入

<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"/> 
<bean id="userService" class="com.lagou.service.impl.UserServiceImpl"> 
	<property name="userDao" ref="userDao"/>

P命名空间注入

P命名空间注入本质也是set方法注入,但比起上述的set方法注入更加方便,主要体现在配置文件中,如下:
首先,需要引入P命名空间:

xmlns:p="http://www.springframework.org/schema/p"

其次,需要修改注入方式:

<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"/> 
<bean id="userService" class="com.lagou.service.impl.UserServiceImpl" p:userDao-ref="userDao"/>

Bean依赖注入的数据类型

注入数据的三种数据类型
1. 普通数据类型
2. 引用数据类型
3. 集合数据类型

public class User { 
	private String username; 
	private String age; 
	
	public void setUsername(String username) { 
		this.username = username; 
	}
	
	public void setAge(String age) { 
		this.age = age; 
	} 
}
<bean id="user" class="com.lagou.domain.User"> 
	<property name="username" value="jack"/> 
	<property name="age" value="18"/> 
</bean>

注入集合数据类型
1)List集合注入

public class UserDaoImpl implements IUserDao {

    // 注入集合数据类型
    private List<Object> list;
    
    public void setList(List<Object> list) {
        this.list = list;
    }
 }   
    <!--进行list集合数据类型的注入-->
        <property name="list">
            <list>
                <value>aaa</value>
                <ref bean="user"></ref>
            </list>
        </property>

2)Set集合注入

public class UserDaoImpl implements IUserDao {

    // 注入集合数据类型
    private Set<Object> set;
    
     public void setSet(Set<Object> set) {
        this.set = set;
    }
 }   
    <!--进行set集合数据类型的注入-->
        <property name="set">
            <set>
                <value>bbb</value>
                <ref bean="user"></ref>
            </set>
        </property>

3)Array数组注入

public class UserDaoImpl implements IUserDao {

    // 注入集合数据类型
   private Object[] array;
    
      public void setArray(Object[] array) {
        this.array = array;
    }
}
   <!--进行array数组数据类型的注入-->
        <property name="array">
            <array>
                <value>ccc</value>
                <ref bean="user"></ref>
            </array>
        </property>

4)Map集合注入

public class UserDaoImpl implements IUserDao {

    // 注入集合数据类型
 private Map<String,Object> map;
    
   public void setMap(Map<String, Object> map) {
        this.map = map;
    }
}
    <!--进行map集合数据类型的注入-->
        <property name="map">
            <map>
                <entry key="k1" value="ddd"></entry>
                <entry key="k2" value-ref="user"></entry>
            </map>
        </property>

5)Properties配置注入

public class UserDaoImpl implements IUserDao {

    // 注入集合数据类型
private Properties properties;
    
   public void setProperties(Properties properties) {
        this.properties = properties;
    }
}
    <!--进行map集合数据类型的注入-->
        <!--进行properties数据类型的注入-->
        <property name="properties">
            <props>
                <prop key="k1">v1</prop>
                <prop key="k2">v2</prop>
                <prop key="k3">v3</prop>
            </props>
        </property>

配置文件模块化

实际开发中,Spring的配置内容非常多,这就导致Spring配置很繁杂且体积很大,所以,可以将部分配置拆解到其他配置文件中,也就是所谓的配置文件模块化。

1)并列的多个配置文件

ApplicationContext act = new ClassPathXmlApplicationContext("beans1.xml","beans2.xml","...");

2)主从配置文件

<import resource="applicationContext-xxx.xml"/>

注意:

  • 同一个xml中不能出现相同名称的bean,如果出现会报错
  • 多个xml如果出现相同名称的bean,不会报错,但是后加载的会覆盖前加载的bean

DbUtils是什么?

DbUtils是Apache的一款用于简化Dao代码的工具类,它底层封装了JDBC技术。

核心对象

QueryRunner queryRunner = new QueryRunner(DataSource dataSource);

核心方法

//执行增、删、改语句
int update(); 

//执行查询语句 ResultSetHandler<T> 这是一个接口,主要作用是将数据库返回的记录封装到实体对象
T query(); 

抽取jdbc配置文件
applicationContext.xml加载jdbc.properties配置文件获得连接信息。
首先,需要引入context命名空间和约束路径:

* 命名空间: 
* xmlns:context="http://www.springframework.org/schema/context" 

* 约束路径: 
* http://www.springframework.org/schema/context 
* http://www.springframework.org/schema/context/spring-context.xsd

context:property-placeholder

<context:property-placeholder location="classpath:jdbc.properties"

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"> 
	<property name="driverClassName" value="${jdbc.driver}"></property> 
	<property name="url" value="${jdbc.url}"></property> 
	<property name="username" value="${jdbc.username}"></property> 
	<property name="password" value="${jdbc.password}"></property>
 </bean>
/>
上一篇:3.IOC理论推导


下一篇:书评:男人来自火星,女人来自金星-约翰.格雷