Spring框架入门-day01

Spring

的核心是控制反转（IoC）和面向切面（AOP）。简单来说，Spring 是一个分层的 JavaSE/EEfull-stack(一站式) 轻量级
开源框架

bean.xml的路径

ApplicationContext context = new
ClassPathXmlApplicationContext(“User.xml”);

• 默认的是从src路径下开始寻找

bean实例化三种方式实现

• 第一种 使用类的无参数构造创建（重点）

  <bean id="user" class="com.User"></bean>
  撒打算 User类里面必须要有无参的构造函数
  如果有有参的构造函数,必须显示写出无参的构造函数

• 第二种 使用静态工厂创建
  创建静态的方法，返回类对象
  <bean id="bean2" class="com.Bean2Factory" factory-method="getUser"></bean>

• 第三种 使用实例工厂创建
  （1）创建不是静态的方法，返回类对象

  <bean id="fa" class="com.Bean3Factory"></bean>
  <bean id="bean3" factory-bean="fa" factory-method="getUser"></bean>
  
  

  因为不是静态方法，所以只能通过类的实例，对象来调用

Bean标签常用属性

（1）id属性：起名称，id属性值名称任意命名

• id属性值，不能包含特殊符号
• 根据id值得到配置对象

（2）class属性：创建对象所在类的全路径

（3）name属性：功能和id属性一样的，id属性值不能包含特殊符号，但是在name属性值里面可以包含特殊符号

• 整合 struts1 的时候: <bean name=”/loginAction” >

（4）scope属性

• singleton：默认值，单例
  就是多次使用(User) context.getBean(“bean2”)，得到的对象是一样的。
• prototype:多例的
• request：创建对象把对象放到request域里面
• session：创建对象把对象放到session域里面
• globalSession：创建对象把对象放到globalSession里面

属性注入介绍

属性注入的方式介绍（三种方式）
（1）使用set方法注入
（2）使用有参数构造注入
（3）使用接口注入
在spring框架里面，支持前两种方式
（1）set方法注入（重点） ，需要属性和set方法。
(name=“对应的是name的set方法”,value的就是要设置的值)

  <!--set方法注入属性-->
    <bean id="user" class="com.User">
        <property name="name" value="张三"></property>
    </bean>

（2）有参数构造注入,需要有属性和有参数的构造函数

<!--属性注入有参数的构造函数-->
    <bean id="user" class="com.User">
        <constructor-arg name="name" value="zz"></constructor-arg>
    </bean>

Bean 的生命周期的配置:

通过配置标签上的 init-method 作为 Bean 的初始化的时候执行的方法，配置 destroy-method
作为 Bean 的销毁的时候执行的方法。
销毁方法想要执行，需要是单例创建的 Bean 而且在工厂关闭的时候，Bean 才会被销毁

注入对象类型属性（重点）

1 创建service类和dao类
（1）在service得到dao对象

2 具体实现过程
（1）在service里面把dao作为类型属性

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

（2）生成dao类型属性的set方法
（3）配置文件中注入关系

    <!--1配置service和dao对象-->
    <bean id="dao" class="com.UserDao"></bean>
    <bean id="service" class="com.UserService">
    此处的name是service类中的UserDao属性名字。但是对应的但是setUserDao方法。
    还有这里不需要value，因为现在设置的值不是字符串，而是一个对象。
        <property name="userDao" ref="dao"></property>
    </bean>

P名称空间注入

第一步:引入 p 名称空间
第二步:使用 p 名称空间

• 普通属性: p:属性名称=””
• 对象类型属性: p:属性名称-ref=””

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


 <bean id="user" class="com.User" p:name="lucy"></bean>
 
 name对应下面的方法，lucy是字符串
 
 public void setName(String name) {
        this.name = name;
    }

注入复杂类型属性

共有四种情况

1 数组 2 list集合 3 map集合 4 properties类型

    <!--复杂类型注入-->
    <bean id="user" class="com.User" >
        <property name="name">
            <list>
                <value>xiao</value>
                <value>li</value>
            </list>
        </property>

        <property name="list">
            <list>
                <value>55</value>
            </list>
        </property>

        <property name="map">
            <map>
                <entry key="age" value="55555555555555"></entry>

            </map>
        </property>

        <property name="properties">
            <props>
                <prop key="username">root</prop>
                
            </props>
        </property>

    </bean>

    private String[] name;
    private List<Integer> list;
    private Map<String,Long> map;

    public void setList(List<Integer> list) {
        this.list = list;
    }

    public void setMap(Map<String, Long> map) {
        this.map = map;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    private Properties properties;

    public User() {
    }

    public void setName(String[] name) {
        this.name = name;
    }

    public String[] getName() {
        return name;
    }

    public List<Integer> getList() {
        return list;
    }

    public Map<String, Long> getMap() {
        return map;
    }

    public Properties getProperties() {
        return properties;
    }

get方法得到的结果
[Ljava.lang.String;@5891e32e
[55]
{age=55555555555555}
{username=root}

IOC和DI区别

（1）IOC: 控制反转，把对象创建交给spring进行配置
（2）DI: 依赖注入，向类里面的属性中设置值

（3）关系：依赖注入不能单独存在，需要在ioc基础之上完成操作

Spring整合web项目原理

1 加载spring核心配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("User.xml");

（1）new对象，功能可以实现，效率很低

2 实现思想：把加载配置文件和创建对象过程，在服务器启动时候完成

3 实现原理
（1）ServletContext对象
（2）监听器
（3）具体使用：

• 在服务器启动时候，为每个项目创建一个ServletContext对象
• 在ServletContext对象创建时候，使用监听器可以具体到ServletContext对象在什么时候创建
• 使用监听器监听到ServletContext对象创建时候，
  – 加载spring配置文件，把配置文件配置对象创建
  – 把创建出来的对象放到ServletContext域对象里面（setAttribute方法）
• 获取对象时候，到ServletContext域得到 （getAttribute方法）

Spring 的分配置文件的开发

一种:创建工厂的时候加载多个配置文件:
ApplicationContext applicationContext = new
ClassPathXmlApplicationContext("applicationContext.xml","applicationContext2.xml");
二种:在一个配置文件中包含另一个配置文件：
<import resource="applicationContext2.xml"></import>