Spring学习笔记-01

于 2019-05-18 03:29:05 发布
阅读量165 收藏
点赞数
分类专栏： 技术专区
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Hero_shine/article/details/90310813
版权

Spring

JavaBean

符合一定规范的（结构雷同）简单Java对象

  1. 必须有包（package）
  2. 必须有无参数构造器
    • 方便子类的继承和创建
    • 方便利用无参数构造器创建对象
  3. 实现序列化接口
    • 方便底层自动调用对象的序列化功能
  4. 属性有get和set访问方法
    • get set 方法声明的属性称为“Bean属性”
    • 类中声明的实例变量称为“对象属性”

符合上述规范类，创建的具体对象称为JavaBean， 也称为简单Java对象，有时候也称为POJO对象。
Spring建议，在Spring中使用JavaBean，也称为简单Java对象，有时候也称为POJO对象。
上述规范不是语法规范，可以不严格遵守，但大多数企业都要求执行上述规范

 Spring核心功能IOC/DI

IOC控制反转： 指对象的创建和控制权利由Spring控制，用户程序只从Spring获取使用对象。 用户程序不再负责创建管理对象。
DI依赖注入：指在需要对象时候，由当前环境创建管理对象，并且注入到使用者手中。

Spring核心功能：

  1. Spring 内部提供了一个JavaBean对象容器（集合）由于创建和管理对象。
  2. 需要提供配置文件（xml文件），Spring根据配置文件创建和管理对象。

如何使用Spring

1.导入Spring框架API

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.3.10.RELEASE</version>
</dependency>

2. 创建一个JavaBean类

/** 符合Java Bean 规范 */
public class HelloWorld implements Serializable {
    private String message = "Hello World";
    public HelloWorld() {
    }

    public String getMessage() {
        return message;
    }
    public void setMessage(String message) {
        this.message = message;
    }
    @Override
    public String toString() {
        return "HelloWorld [message=" + message + "]";
    }
}

3. 创建一个XML配置文件，告知Spring创建哪些bean对象

<?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" 
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"  
    xmlns:jee="http://www.springframework.org/schema/jee" 
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:util="http://www.springframework.org/schema/util"
    xmlns:jpa="http://www.springframework.org/schema/data/jpa"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
        http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">

    <!-- 利用配置文件，告诉Spring管理哪些JavaBean对象 -->
    <bean id="obj" class="day01.HelloWorld"/>

</beans>

 4.启动Spring容器，Spring会根据XML文件创建对象，并获取对应创建好的的对象。

public class TestCase {
	
	ClassPathXmlApplicationContext ctx;
	
	@Before//在测试案例之前执行
	public void initCtx() {
		
		//初始化Spring：
		//需要提供配置文件
		//配置文件默认位置为resources
		ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
	}
	
	
	@Test
	public void testHelloWorld() {
		
		//Spring中就已经创建了HelloWorld对象
		//利用id获取Spring中创建的对象
		HelloWorld obj = (HelloWorld)ctx.getBean("obj");
		System.out.println(obj);
	}

        @After//在测试案例之后执行
	public void destroy() {
		ctx.close();
	}

}

Spring容器

     Spring 核心功能是管理JavaBean对象，由于其内部缓存了JavaBean对象，所以形象称为Spring为 JavaBean 容器。

  1. Spring为 JavaBean 容器。
  2. 由于Spring可以创建JavaBean对象，所以称为BeanFactory（JavaBean的工厂）
  3. 后来Spring在BeanFactory基础上扩展了接口 ApplicationContext。
    • 一般常用是 ApplicationContext
    • Application 应用，Context 上下文环境
    • 实际常用实现类是 ClassPathXmlApplicationContext
    • ClassPathXmlApplicationContext 是Spring容器、Bean容器也是Bean工厂

Spring 容器功能使用

  Spring容器提供了多个获取Bean对象的方法：

//返回是Object类型需要进行类型转换
Object bean = ctx.getBean("BeanID")

//返回具体类型的Bean对象     
类型 obj = ctx.getBean("BeanID", 类型)

案例：

<!-- 利用配置文件，告诉Spring管理哪些JavaBean对象 -->
<bean id="obj1" class="day01.HelloWorld"/>
<!-- id 属性和 name属性作用一样 -->
<bean name="obj2" class="day01.HelloWorld"/>

@Test
public void testName() {
    //利用name属性获取Spring容器中的对象
    HelloWorld obj=(HelloWorld)ctx.getBean("obj2");
    //检查是否成功创建了对象
    System.out.println(obj); 
}

@Test
public void testGetBean() {
    //Spring容器提供了多个获取Bean对象的方法：
    HelloWorld bean1 = 
            (HelloWorld)ctx.getBean("obj1");
    System.out.println(bean1);
    //返回具体类型的方法，无需类型转换（常用）
    HelloWorld bean2 = 
            ctx.getBean("obj1", HelloWorld.class);
    System.out.println(bean2); 
}

Spring 创建对象的方式

1.利用无参数构造器创建对象
   默认情况下，Spring会自动调用（反射调用）无参数构造器创建对象

2.利用静态工厂方法创建对象, Spring可以利用工厂方法来创建对象

//配置文件：
<!-- Spring利用静态工厂方法创建对象 -->
<bean id="cal1" class="java.util.Calendar" factory-method="getInstance"/> 

//测试案例：
@Test 
public void testCalendar() {
    //静态方法getInstance()，来创建Calendar对象
    //创建对象的静态方法称为，静态工厂方法。
    //Calendar cal = Calendar.getInstance();

    //Spring支持静态工厂方法创建对象
    //Spring可以去调用静态工厂方法，将创建的对象
    //放到Spring容器管理起来，提供给外部使用。

    Calendar cal1 =  ctx.getBean("cal1", Calendar.class);
    System.out.println(cal1); 
}

3.利用对象工厂方法创建对象

<bean id="date1" factory-bean="cal1" factory-method="getTime"/>

@Test 
public void testFactoryBean() { 
//测试利用Spring调用Bean对象的工厂方法创建对象 
    Date date = ctx.getBean("date1", Date.class); 
    System.out.println(date); 
}

单例与多例

单例的特点：

  1. 资源占用少， 一个对象可以被复用。
  2. 并发访问时候，单例对象的属性可能出现并发访问问题。

多例的特点：

  1. 每个实例都有一组数据，资源占用高，可以保持多个状态
  2. 如果每个线程访问一个实例，就没有线程并发安全问题
<!-- scope="prototype" 属性设置以后，obj3 
是多例的，每次getBean都会创建一个新对象-->
<bean id="obj3" class="day01.HelloWorld" scope="prototype"/>

对象的生命周期管理

生命周期管理方法用于初始化，或者回收资源。

1.默认情况下是单例对象，Spring利用属性调用初始化和销毁方法
    容器启动时调用初始化方法
    容器关闭时调用销毁方法

<!-- 测试对象生命周期管理方法 -->
<bean id="demo" class="day01.DemoBean" init-method="init" destroy-method="destroy"/>

2.多例对象时，Spring只在创建对象时调用init方法，不会调用销毁方法，销毁方法只能手动执行

<!-- 测试对象生命周期管理方法 -->
<bean id="demo" class="day01.DemoBean" scopt="prototype"
    init-method="init" destroy-method="destroy"/>

案例：
 

public class DemoBean implements Serializable{
    private PrintWriter out;

    public void init() {
        //初始化资源
        try {
            out = new PrintWriter("demo.txt");
            System.out.println("打开文件 demo.txt"); 
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
    public void destroy() {
        //关闭资源
        out.flush();
        out.close();
        System.out.println("文件被关闭了"); 
    }
    public void print(String str) {
        out.println(str); 
    }
}

public class DemoBean2 implements Serializable{
    private PrintWriter out;

    public void init() {
        //初始化资源
        try {
            out = new PrintWriter("demo2.txt");
            System.out.println("打开文件 demo2.txt"); 
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
    public void destroy() {
        //关闭资源
        out.flush();
        out.close();
        System.out.println("文件被关闭了"); 
    }
    public void print(String str) {
        out.println(str); 
    }
}

<!-- 测试对象生命周期管理方法 -->
<bean id="demo" class="day01.DemoBean" init-method="init" destroy-method="destroy"/>

<!-- 测试多例对象的生命周期管理方法 destroy-method 写上没有意义，不会被执行-->
<bean id="demo2" class="day01.DemoBean2" scope="prototype" init-method="init"/>

@Test
public void testLifecircle() {
    //测试Spring的Bean对象的生命周期管理功能
    DemoBean bean = ctx.getBean("demo", DemoBean.class);
    bean.print("abc"); 
}

@Test
public void testPrototypeLifecircle() {
    //测试Spring多例Bean对象的生命周期管理功能
    DemoBean2 bean = ctx.getBean("demo2", DemoBean2.class);
    bean.print("abc");
    //手工调用销毁方法
    bean.destroy();
}

懒惰实例化JavaBean

     设置bean属性lazy-init="true"： 在第一次请求getBean时候实例化对象。

  1. 默认情况下Spring对于单例对象，容器启动时候立即实例化。优点是在使用对象时候，对象已经实例化，可以减少延迟，提高性能。 会占用系统资源。
  2. lazy-init="true" 属性，以后按需实例化，资源占用低，获取对象慢。
  3. 对于一定使用的对象，建议采用立即实例化规则
  4. 对于使用少的对象建议采用懒惰实例化
  5. Spring默认规则是 立即实例化
<!-- 测试对象生命周期管理方法 -->
<bean id="demo" class="day01.DemoBean" lazy-init="true" 
    init-method="init" destroy-method="destroy"/>

 

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值