Spring是一个分层的JavaSE/EE full-stack(一站式) 轻量级开源框架。

具体介绍参考

一：IoC(Inversion of Control)控制反转，将创建对象实例反转给spring，交给IoC容器

1，底层原理：工厂模式+配置文件+反射

小测试：

public class SpringDemo1 {
    @Test
    public void demo01(){
        //普通方法实现对象
        UserDao dao=new UserDaoImp();
        dao.save();
    }
    @Test
    public void demo02(){
        //ioc方式实现对象
        //创建Spring工厂
        ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
        //通过反射获取实现类
        UserDao userDao = (UserDao) ac.getBean("UserDao");
        userDao.save();
        
    }
}

2，DI(依赖注入）

面向对象有：

• 依赖 a 依赖b (a中有b,比如 a中的方法有 public void save(b) )
• 继承 a is b(a继承b)

• 聚合 a has b(a聚合b)
  主要就是对象（应用程序）依赖IoC容器向应用程序中注入其所需要的外部资源（对象，资源，变量）
  具体可以参考这篇博文

  3，Spring工厂类

  
• BeanFactory*(老版本模式)在调用 getBean(类ID) 方法时才会创建该类
• ApplicationContext*(现在较常用的Spring工厂类）在加载配置文件的时候就会实例化IoC容器中的类
  在最底层有两个实现类：
• ClassPathXmlApplicationContext("applicationContext.xml") 加载类路径下即src下的配置文件（常用）

• FileSystemXmlApplicationContext("applicationContext.xml") 加载系统文件下即磁盘下的配置文件

  4,Spring的配置

  bean的属性配置（了解)
• id:配置的类的名字,有唯一性约束，不能有特殊符号
• name:也是配置的类的名字，没有唯一性约束，可以有特殊符号
• class:配置的类的全路径
  配置的类的生命化周期：

<bean id="UserDao" class="com.test.spring.UserDaoImp" init-method="init" destroy-method="destroy"/>

在配置的类中写 init() ,和 destroy() ，在创建类实例的时候会自动执行 init() 方法，当工厂关闭时，会执行destroy()方法（前提是默认创建的类是单例）
bean标签的作用范围配置（重点）
对scape属性的配置:

• singleton(默认值，交给IoC容器创建的类为单例）
• prototype(多例，将Action类交给IoC容器是需要设置为多例）
• request(在Web工程下，创建的类会被引入request域中）

• session(在Web工程下，创建的类会被引入到session域中）

  5,Spring中属性注入

  1,利用有参构造方法

public class Car {
    private String name;
    private double price;
    public Car(String name, double price) {
        super();
        this.name = name;
        this.price = price;
    }
    @Override
    public String toString() {
        return "Car [name=" + name + ", price=" + price + "]";
    }
    
}

<bean id="Car" class="com.test.spring.Car">
<!-- 构造方法注入属性 -->
<constructor-arg name="name" value="马车"/>
<constructor-arg name="price" value="100000.9"/>
</bean>

2,set方法注入

public class Car1 {
    private String name;
    private double price;
    public void setName(String name) {
        this.name = name;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    @Override
    public String toString() {
        return "Car1 [name=" + name + ", price=" + price + "]";
    }
    
}

<bean id="Car1" class="com.test.spring.Car1">
<!-- set方法注入属性 -->
<property name="name" value="跑车"/>
<property name="price" value="12334"/>
</bean>

set方法设置对象类型的注入：

public class User {
    private String name;
    private Car car;
    public void setName(String name) {
        this.name = name;
    }
    public void setCar(Car car) {
        this.car = car;
    }
    @Override
    public String toString() {
        return "User [name=" + name + ", car=" + car + "]";
    }
    
}

<bean id="User" class="com.test.spring.User">
<!-- 属性为类时的注入 -->
<property name="name" value="李氏"/>
<property name="car" ref="Car"/>
</bean>

2.1,p名称空间的属性注入（类中属性也需要提供set方法）
首先需要引入p名称空间

如何引入：

<!-- 利用P名称空间来注入普通属性 -->
<bean id="Car1" class="com.test.spring.Car1" p:name="马车p" p:price="300000000"/>
<!-- p名称空间方式引入对象属性 -->
<bean id="User" class="com.test.spring.User" p:name="邬八" p:car-ref="Car"/>

2.2SpEL(Spring Exception Language)可以调用其他类中的属性和方法
例子：

public class CarInfo {
    private String name;
    public String getName(){
        return "spel马车";
    }
    public double priceInfo(){
        return Math.random() * 5000;
    }
}

<!--通过SpEL完成注入属性 -->
<bean id="Car1" class="com.test.spring.Car1">
<property name="name" value="#{CarInfo.name}"/>
<property name="price" value="#{CarInfo.priceInfo()}"/>
</bean>
<bean id="CarInfo" class="com.test.spring.CarInfo"/>

3,集合类型的属性注入（一般在整合Spring和Hibernate）时用到

public class CollectBean {
    private String[] arrs;
    private List<String> list;
    private Set<String> set;
    private Map<String,String> map;
    public void setArrs(String[] arrs) {
        this.arrs = arrs;
    }
    public void setList(List<String> list) {
        this.list = list;
    }
    public void setSet(Set<String> set) {
        this.set = set;
    }
    public void setMap(Map<String, String> map) {
        this.map = map;
    }
    @Override
    public String toString() {
        return "CollectBean [arrs=" + Arrays.toString(arrs) + ", list=" + list + ", set=" + set + ", map=" + map + "]";
    }
    
}

<!-- 集合类型的属性注入 -->
<bean id="CollectBean" class="com.test.spring.CollectBean">
<property name="arrs">
<list>
<value>李氏</value>
<value>王五</value>
</list>
</property>
<property name="list">
<list>
<value>大吉</value>
<value>大力</value>
</list>
</property>
<property name="set">
<set>
<value>厉害</value>
<value>不厉害</value>
</set>
</property>
<property name="map">
<map>
<entry key="1" value="11"/>
<entry key="2" value="22"/>
</map>
</property>
</bean>

二，Spring分模块开发的配置

1，引入多个配置文件

ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml","applicationContext2.xml");

2，在一个配置文件中引入多个配置文件

<!-- 在src下 直接引入文件名，在包下比如  com/test/applicationContext4.xml-->
<import resource="applicationContext3.xml"/>

注意：将dao层的对象作为相应的service层中类中的属性，这样在创建一次spring工厂即可

public class CustomerServiceImp implements CustomerService {
    private CustomerDao customerDao;
    public void setCustomerDao(CustomerDao customerDao) {
        this.customerDao = customerDao;
    }
    @Override
    public void save(Customer customer) {
        System.out.println("CustomerServiceImp执行了");
        customerDao.save(customer);
    }
    
}

<bean id="CustomerServiceImp" class="com.test.service.imp.CustomerServiceImp">
<!-- 属性注入dao实现类对象 -->
<property name="customerDao" ref="CustomerDaoImp"/>
</bean>
<bean id="CustomerDaoImp" class="com.test.dao.imp.CustomerDaoImp"></bean>

Spring_简单入门（学习笔记1）

原文：https://www.cnblogs.com/wuba/p/11031599.html