spring框架之(1)

1.1.看透软件
软件定义？
软件作用？
软件实现？
1.2.看透框架
框架的定义
框架在软件中的一个定位
框架应用的动机
1.3.看透SPRING
Spring 是什么
Spring 应用场景
Spring 应用理由
Spring 基本应用

1.4.Spring IOC基本应用
Spring IOC 概述
Spring IOC 容器
Spring Bean 对象

2.课程内容
2.1.看透软件
软件的定义：程序和文档的集合
程序：数据结构（线性结构，树结构，图结构）+算法
软件解决的共性问题：IPO=输入+处理+输出
互联网永恒不变的的基本架构：C(Client)/S(Server)
2.2.看透框架
框架（FrameWork）：软件中的一个半成品。
框架要解决软件中的什么问题：共性问题（对象构建，对象持久化，应用架构）
例如：
1)Spring 能帮我们解决对象构建问题
2)Spring MVC 能帮我们简化MVC架构的处理过程。
3)MyBatis能帮我们更好的解决数据的持久化问题。
4)……
2.3.看透SPRING
Spring 是什么？轻量级的框架(Framework)
Spring 应用动机？从多个维度更好的解决问题（面向对象，面向切面，面向服务）
Spring 应用核心？IOC，AOP，MVC，。。。

3.Spring IOC

3.1.Spring IOC 概述
Spring IOC 是Spring框架一个核心，称之为控制反转，严格来讲就是我们将软件项目中对象的创建以及管理交给Spring。当我们使用对象时，从spring容器获取就可以了。

FAQ?
1)Spring 框架如何知道你写了哪些类，哪些类的对象由spring管理。
a）以xml配置文件的方式告诉它
b）以注解方式告诉它。
2)Spring 会如何构建这些对象？（通过反射Class.forName(“包名.类名”)）
3)Spring 会如何存储这些对象？（底层会借助map存储对象）

3.2.Spring IOC 编程

3.3.基本步骤

step01:创建JAVA项目（CGB-SPRING-DAY01-IOC-01）
step02:添加SPRING依赖(创建lib目录，然后将jar放入，添加到buildpath)
step03:拷贝项目配置模板(直接放入src根目录)
step04:定义并配置bean对象（目前可以简单理解为普通的java对象）
step05:初始化SPRING容器，获取我们需要的bean对象。

3.4.基本实现

3.4.1.创建Java项目
在eclipse中创建一个java项目，命名为CGB-SPRING-DAY01-IOC-01
3.4.2.添加项目依赖
下载jar包，并添加到项目的build path中。

扫描二维码关注公众号，回复： 3432532 查看本文章

3.4.3.添加配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans 
    default-lazy-init="default"
    xmlns="http://www.springframework.org/schema/beans" 
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:context="http://www.springframework.org/schema/context"
    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-4.3.xsd  
       http://www.springframework.org/schema/mvc   
       http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd   
       http://www.springframework.org/schema/tx   
       http://www.springframework.org/schema/tx/spring-tx-4.3.xsd   
       http://www.springframework.org/schema/aop 
       http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
       http://www.springframework.org/schema/util 
       http://www.springframework.org/schema/util/spring-util-4.3.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/context
       http://www.springframework.org/schema/context/spring-context-4.3.xsd"> 

</beans>

3.4.4.定义描述bean

在配置文件中添加

<bean id="date" class="java.util.Date"/>

3.4.5.初始化spring容器

private static ClassPathXmlApplicationContext ctx;
    static{
        ctx=new ClassPathXmlApplicationContext(
                "applicationContext.xml");
    }

3.4.6.
3.4.7.获取bean对象

public static void main(String[] args) {
        System.out.println(ctx);
        Date date1=(Date)ctx.getBean("date");
        System.out.println(date1);
    }

3.5.Spring 中Bean对象

3.5.1.Bean对象的定义及初始化

Bean类型的创建：
1）访问修饰符：public （尽量使用public）
2）提供无参的构造函数（可以为私有）
Bean 类型在xml文件中的配置(通过id或name属性指定bean名称，class属性指定类全名)

<bean id=”helloService” class=”bean.HelloService”/>

说明:bean的这个名字必须具备全局唯一性。

Bean对象的初始化：（由spring工厂负责创建，并存储到spring容器，例如map）
1)直接通过无参构造函数构建

<bean id="date" class="java.util.Date"/>

2)借助类型的静态工厂方法构建

<bean id="cal" class="java.util.Calendar" factory-method="getInstance" />

3)借助实例对象相关方法获取对象

<bean id="date2" factory-bean="cal" factory-method="getTime"/>
<bean id="cal" class="java.util.Calendar" factory-method="getInstance" />

3.5.2.Bean对象的作用域及生命周期
Spring容器管理的Bean对象默认是单例作用域(singleton),假如希望每次获取对象都要创建新的对象可以采用prototype作用域。

Spring Bean对象的作用域可以通过Bean元素中的scope属性进行指定，例如。
将Bean作用域设置为singleton

<bean id="helloService" 
            class="bean.HelloService"
            scope="singleton"
            init-method="doInit"
            destroy-method="doDestroy"/>

将Bean作用域设置为prototype

  <bean id="date" 
            class="java.util.Date"
init-method="doInit"
            scope="prototype"/>

其中Bean中的init-method,destroy-method属性用于指定bean对象的生命周期方法，对于init-method属性指定的方法会在对象构建完成以后自动调用。对于destory-method属性指定的方法，假如bean的作用域是singleton，那在spring容器销毁时会自动执行。

FAQ?
1.Spring 中的作用域的配置是从哪些维度解决软件中的共性问题?
1)对象创建（单例，多例）
2)对象管理（单例对象会存储到map，需要时从map获取）
3)对象销毁 (单例对象会在容器销毁时自动销毁，然后被GC)。

3.5.3.Bean对象的延迟加载
对于Spring而言，它管理的Bean对象默认情况下会在bean容器启动时创建，并初始化。但是有些对象我们可能长时间不用，这样就会造成一定
的资源浪费。此时我们可以对这些Bean设置为延迟加载，所谓延迟加载就是在容器启动时不会初始化它，只有在使用时才初始化。
Bean对象延迟加载设置：
1)bean元素内部设置（借助lazy-init属性）
2)beans根元素中设置（借助default-lazy-init属性）

例如：
1）内部设置的：

<bean id="helloService" 
            class="bean.HelloService"
            scope="singleton"
            init-method="doInit"
            destroy-method="doDestroy"
            lazy-init="true"/>

2）根元素设置的：

public class DataSource{
    private String driver;
    private String url;
    private String username;
    private String password;

    public DataSource() {
    }
    public DataSource(String driver,String url,
            String username,String password) {
        this.driver=driver;
        this.url=url;
        this.username=username;
        this.password=password;
    }
    public String getDriver() {
        return driver;
    }
    public void setDriver(String driver) {
        this.driver = driver;
    }
    public String getUrl() {
        return url;
    }
    public void setUrl(String url) {
        this.url = url;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    @Override
    public String toString() {
        return "DataSource [driver=" + driver + ", url=" + url + ", username=" + username + ", password=" + password
                + "]";
    }
}

DataSource配置及值的注入

set注入：
<bean id="dataSource1" class="beans.DataSource">
          <property name="driver" value="com.mysql.jdbc.Driver"/>
          <property name="url" value="jdbc:mysql:///test"/>
          <property name="username" value="root"/>
          <property name="password" value="123456"/>
</bean>

构造注入：

   <bean id="dataSource2" class="beans.DataSource">
           <constructor-arg value="com.mysql.jdbc.Driver"/>
           <constructor-arg value="jdbc:mysql:///test"/>
           <constructor-arg value="root"/>
           <constructor-arg value="123456"/>
       </bean>

案例2：

定义JDBCTemplate
public class JdbcTemplate {

    private DataSource dataSource;
    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }
}

配置JdbcTemplate及实现值的注入

 <bean id="jdbcTemplate" 
             class="beans.JdbcTemplate">
           <property name="dataSource" 
                     ref="dataSource1"/>
       </bean>

猜你喜欢