Spring初识、IOC应用

框架学习
学习他帮我们做了什么。我们还需要做些什么。
还有熟悉框架的设计思想，至于如何实现以后再去考虑
终于学习框架了。开心。

Spring框架学习

1、Spring框架作用

a.Spring Core （IOC功能）
b.Spring AOP功能

(管理组件对象，维护对象关系 目的：降低组件耦合度)

c.Spring Web MVC 功能
(MVC设计，目的：架构一个MVC结构的Web程序)

d.Spring整合其他技术，例如JDBC，MyBatis,Hibernate,Struts等
在Spring中使用整合API编程。

结构图：

2、Spring IOC应用

a.管理对象

创建，初始化，释放资源，销毁。

使用IOC功能创建对象

b.建立对象关系
Dependency Injection 依赖注入
依赖注入：set方法注入 构造器注入

c.搭建SpringIOC开发
引入相关jar包，在src添加applicationContext.xml

配置完是这样

实例化 ApplicationContext容器对象–>applicationContext.xml --><bean>
会帮你new出来，创建对象。

正常的创建对象，是用new 。可以用Spring来实现new
把要进行创建的类写入配置文件applicationContext.xml里

<!-- 采用new GregorianCalendar() -->
    <bean id="c1" class="java.util.GregorianCalendar"></bean>

在类里要先创建 Spring的配置文件即 applicationContext.xml 。然后通过getBean方法获取即

public static void main(String [] args){

        Calendar c1 = new GregorianCalendar();
        Calendar c2 = Calendar.getInstance();
        //创建Spring容器对象
        String conf = "applicationContext.xml";
        //根据这个applicationContext.xml来实例化配置对象 ！！要写全，即.xml也要写
        ApplicationContext ac = new ClassPathXmlApplicationContext(conf);
        //从Spring容器获取c1 就是配置文件中定义的 id
        //返回的都是Object，也可以进行强制转换。
        Calendar c3 = ac.getBean("c1",Calendar.class);
        System.out.println(c3);
    }

Spring 容器 管理组件及对象关系

1、创建ApplicationContext对象
2、向applicationContext.xml配置<bean>
3、利用ApplicationContext对象getBean()

这个只是通过new的方式创建的

那么通过类名调用静态方法

同样在配置文件中配置

<!-- 采用 Calendar.getInstance(),静态工厂方法 -->
    <bean id="c2" class="java.util.Calendar" factory-method="getInstance"></bean>

在类中调用

        Calendar c4 = ac.getBean("c2",Calendar.class);
        System.out.println(c4);

还有一种是对象调用方法返回另一个对象

    <!--采用c4.getTime() 对象工厂方法 -->
    <bean id="date" factory-bean="c2" factory-method="getTime"></bean>

那个c2 就是factory-bean 是那个之前写的id=”c2” ！！！对象的id名。然后 factory-method是这个c2要调用的方法。他也会返回一个对象

于是在类中写：

    Date date = ac.getBean("date",Date.class);
        System.out.println(date);

2、Spring创建Bean对象的控制

a.控制对象创建方式(使用范围)
在<bean>元素中使用scope属性控制
scope可以支持singleton或prototype
默认值是singleton
实现效果就是单例
<bean scope=”singleton”>该组件在Spring容器里只有一个bean对象
取的就是只有这一个对象。对应的prototype就是该组件每次ac.getBean(“id”)都返回一个新的对象。
一般情况下就用默认也就是单例。

自己写一个bean，然后Spring帮助创建 new

ExampleBean.java

package bean;

public class ExampleBean {
    public void execute(){
        System.out.println("调用execute方法！");
    }
}

配置

<!-- 自己写的bean -->
    <bean id="e1" class="bean.ExampleBean"></bean>

    ExampleBean eb = ac.getBean("e1",ExampleBean.class);
        eb.execute();

但是对于类似一个Emp那种的就不能是单例了。就是有属性的。对应的会是属性也变成单例的了。永远操作的都是一个。
b.指定对象初始化方法
可以在构造方法中写。
或者
写任意方法中。在配置bean中配置该方法
init-method=”该方法” 用该方法指定，当创建对象后自动执行init-method方法

c.指定对象销毁方法
类似的在配置文件中配置属性 destory-method
属性值是对应的在bean中的写的方法。
正常运行后不会调用这个方法。但是把容器配置对象close后才会调用这个销毁方法。不止是自己写的。会调用单例进行销毁。
这个设置的销毁方法是针对组件是单例模式，并且调用容器配置对象的close方法。才会执行这个方法。
不是单例的话是不会执行这个的方法的。
d.控制单例对象创建时机
lazy-init属性 延迟实例化
属性值是true和false
默认的话是容器对象创建就会执行创建单例对象。加上这个属性后。会延迟单例对象的创建。当创建出来的容器对象调用getBean方法时才会调用该单例的构造方法即创建单例对象。

写一个bean 正常是在代码中用set方法设置其属性。

用Spring配置：
利用信息注入来设置
配置：

<bean id="p1" class="bean.computer" >
    <!-- 信息set注入 -->
    <property name="cpu" value="骁龙"></property>
    <property name="gpu" value="AMD"></property>
    <property name="mainbord" value="华硕"></property>
    </bean>

类中创建

computer p1 = ac.getBean("p1",computer.class);
        p1.show();

创建出来的都是在配置中设置的值

降低这个信息与computer的耦合
这个叫做set注入！
如果出现错误就去控制台看找 Caused by 查看异常错误。

还有构造器注入：

bean.Phone.java

package bean;

public class Phone {
    private String cpu;
    private String ram;

    public Phone(String cpu,String ram){
        this.cpu=cpu;
        this.ram=ram;
    }

    public void show(){
        System.out.println("手机配置");
        System.out.println("cpu:"+cpu);
        System.out.println("ram:"+ram);
    }
}

配置：

<bean id="p2" class="bean.Phone">
        <!--构造器注入  -->
        <constructor-arg index="0" value="高通">
        </constructor-arg>

        <constructor-arg index="1" value="4G">
        </constructor-arg>
    </bean>

    Phone p2 = ac.getBean("p2",Phone.class);
        p2.show();

利用的是构造方法来实现设置其属性值。不同的就是bean中写的是构造方法，并设置参数。
然后在配置中利用<constructor-arg>标签设置属性值
index 是第几个参数。value是设置其属性值。
这个用的比较少。

注入的不止是字符串，还可以是对象
bean.Student.java

package bean;

public class Student {
    private computer c;
    private Phone p;

    public void show(){
        c.show();
        p.show();
    }

    public void setC(computer c) {
        this.c = c;
    }

    public void setP(Phone p) {
        this.p = p;
    }
}

配置：

<bean id="s1" class="bean.Student">
    <!-- 利用set注入 -->

    <property name="c" ref="p1" ></property>
    <property name="p" ref="p2"></property>

    </bean>

name是这个Student中两个属性名 用ref来把对象赋给所对应的参数。
那个p1是前面computer的name p2是前面的Phone

Student s1 = ac.getBean("s1",Student.class);

        s1.show();

IOC概念：

Inversion of Control 控制反转，反向控制
控制反转：改变对象获取方式。之前编码方式采用 new 构造器获取对象，IOC采用由容器创建对象，之后注入进来使用。
就是把对象获取方式改了。控制权在Spring了。只要修改配置就会改变对象关系。
对象以注入方式使用。