Spring框架①

諒Spring框架①

简介：Spring:春天，泉水的意思，本文简单介绍IOC（控制反转）、DI（依赖注入），Spring主要是管理对象的创建以及生命周期的框架，对象的创建更高效，可以实现高内聚，低耦合（框架底层通过反射实现创建对象）。

IOC（控制反转）
三种对象创建方式
DI依赖注入
自动装配IOC
IOC扫描小案例⭐
Bean的作用域与生命周期

1、IOC（控制反转）

主要读取核心配置ApplicationContext，通过spring.xml配置文件管理对象，利用

小案例：

//User.java文件：》》》
public class User {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + ''' +
                ", age=" + age +
                ", address='" + address + ''' +
                '}';
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public User() {
    }

    private String address;
}

spring.xml文件：

//TestSpring.java文件：
public class Test1 {
    @Test
    public void test1(){
        ApplicationContext app=new ClassPathXmlApplicationContext("sp.xml");
        User demo=app.getBean("user", User.class);
        System.out.println(demo);
    }
}

结果：

2、三种对象创建方式 ① IOC中几种实例化Bean的方式：

⭐无参构造：
跳转上面的案例就是了

⭐带参构造的三种方式：

Car01.java文件：

public class Car01 {
    public String getName() {
        return name;
    }

    public Car01(String name, int price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car01{" +
                "name='" + name + ''' +
                ", price=" + price +
                '}';
    }

    public Car01() {
    }

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

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }
    private String name;
    private int price;
}

spring.xml

AppTest.java文件：》》

public class AppTest {
//    有参构造创建对象通过name属性测试
    @Test
    public void bean(){
        //获取核心配置文件对象
        ApplicationContext bean01=new ClassPathXmlApplicationContext("spring.xml");
        Car01 c1=bean01.getBean("car01", Car01.class);
        System.out.println(c1);
    }
    //        index和type属性两种
    @Test
    public void bean01(){

        ApplicationContext bean01=new ClassPathXmlApplicationContext("spring.xml");
        Car01 c2=bean01.getBean("car2", Car01.class);
        System.out.println(c2);
    }
}

结果：

② 工厂模式之静态工厂实例化

没啥可说的直接上代码：

工厂类Factory.java

public class Factory {
    //静态工厂
    public static Car01 method(){
        return new Car01("自行车",1000);
    }
}

Car01.java

public class Car01 {
    public String getName() {
        return name;
    }

    public Car01(String name, int price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car01{" +
                "name='" + name + ''' +
                ", price=" + price +
                '}';
    }

    public Car01() {
    }

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

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    private String name;
    private int price;
}

spring.xml文件：

测试文件：

//工厂模式静态工厂
    @Test
    public void factory(){
        ApplicationContext bean01=new ClassPathXmlApplicationContext("spring.xml");
        Car01 c3=bean01.getBean("car3", Car01.class);//静态工厂实例化
        System.out.println(c3);
    }

结果：

③ 工厂模式之非静态实例化

工厂类Factory.java

public class Factory {
   //非静态
    public Car02 method1(){
        return new Car02("公交车",2500);
    }
}

Car01.java

public class Car01 {
    public String getName() {
        return name;
    }

    public Car01(String name, int price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car01{" +
                "name='" + name + ''' +
                ", price=" + price +
                '}';
    }

    public Car01() {
    }

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

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    private String name;
    private int price;
}

spring.xml文件：

测试文件：

//    工厂模式非静态
    @Test
    public void factory1(){
    ApplicationContext bean01=new ClassPathXmlApplicationContext("spring.xml");
    Car02 c3=bean01.getBean("car4", Car02.class);//静态工厂实例化
    System.out.println(c3);
}

结果：

其实静态工厂与非静态工厂区别在于，静态工厂可以直接调用方法，而非静态工厂则需要创建对象再去调用方法。

3、DI依赖注入

对象的注入，其实就是对象的初始化，主分五种：
- ①Set注入⭐
- ②构造器
- ③静态工厂
- ④实例化工厂
- ⑤p标签(是Set注入的变种）

综合案例直接对全部注入进行练习：
SpringDI.java文件：

//注入练习
public class SpringDI {
    private String name;
    private int age;
    private Car car;
    private String[] habby;
    private List list;
    private Set set;
    private Map map;
    private Properties pro;//配置文件类型
    //构造器，set,get，toString,方法省略太占位置，大家自己生成吧
 }

Car.java

class Car{
    private String name;
	private int price;
    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + ''' +
                ", price=" + price +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }
}

Spring01.xml配置：

DITest测试文件：

public class DITest {
    @Test
    public void test(){
        //引入配置
        ApplicationContext app=new ClassPathXmlApplicationContext("spring01.xml");
        SpringDI di=app.getBean("di", SpringDI.class);
        System.out.println(di);
    }
}

结果:

4、自动装配IOC

两种注解方式：@Autowired和@Resource，注解的配置，可以简化配置文件，提高开发的速度，使程序看上去更简洁,需要导入依赖avax.annotation-api

@Autowired：根据对象类型装配
@Resource：根据对象名装配

    
      org.springframework
      spring-context
      5.3.9
    
    
    
      javax.annotation
      javax.annotation-api
      1.3.2

①.@Autowired：来源于Spring框架

代码演示：Demo和Demo1.java文件内容

//------------------Demo.java------------------------
public class Demo {
    @Autowired
    Demo1 d;
    public void test(){
        d.test();
        System.out.println("D-------------");
    }
}
//------------------Demo1.java-----------------------
public class Demo1 {
    public void test(){
        System.out.println("demo1---------");
    }
}

spring.xml文件

测试文件；

    @Test
    public void test(){
        ApplicationContext app=new ClassPathXmlApplicationContext("sp.xml");
        Demo demo=app.getBean("Demo",Demo.class);
        demo.test();
    }

结果：

②.@Resource：来源于java扩展工具包

代码演示：Demo和Demo1.java文件内容

//------------------Demo.java------------------------
public class Demo {
    //@Resource 这个方法不指定名字则会自动扫描，不建议
    @Resource(name = "Demo1")
    Demo1 d;
    public void test(){
        d.test();
        System.out.println("D-------------");
    }
}
//------------------Demo1.java-----------------------
public class Demo1 {
    public void test(){
        System.out.println("demo1---------");
    }
}

spring.xml文件

测试文件；

    @Test
    public void test(){
        ApplicationContext app=new ClassPathXmlApplicationContext("sp.xml");
        Demo demo=app.getBean("Demo",Demo.class);
        demo.test();
    }

结果：

5、IOC扫描小案例⭐

简单扫描，复杂配置
主要是通过简单的配置，实现不在文件中new对象，利用自动扫描，实现多层方法的调用

①导入依赖

 
    
      org.springframework
      spring-context
      5.2.4.RELEASE
    
    
    
      javax.annotation
      javax.annotation-api
      1.3.2

② 三层开发dao层，service层，controller控制层

dao层：Userdao.java

import org.springframework.stereotype.Repository;

@Repository
public class Userdao {
    public void test(){
        System.out.println("Userdao..................");
    }
}

service层：UserService.java

@Service
public class UserService {

    @Autowired
    public Userdao dao;

    public void test(){
        dao.test();
        System.out.println("UserService..............");
    }
}

controller层：UserController.java

@Controller
public class UserController {

    //@Autowired
    @Resource(name = "services")
    UserService service;

    public  void test(){
        service.test();
        System.out.println("UserController...................");
    }
}

③ spring.xml配置文件

④ AppTest测试文件

    @Test
    public void test() {
    //首先获取配置文件
        ApplicationContext app=new ClassPathXmlApplicationContext("spring1.xml");
        //获取Controlle层对象并调用test()方法
        UserController uc=app.getBean("userController", UserController.class);
        uc.test();
    }

测试结果：

补充：和导入和读入：

配置文件spring2导入spring1.xml和jdbc.properties文件：

这样通过获取spring2.xml就可以获取到spring1.xml中的所有对象了

6、Bean的作用域与生命周期

默认情况下，我们从Spring容器中拿到的对象均是单例的，对于bean的作用域类型如下：
- singleton 作用域
  
  注意: lazy-init是懒加载, 如果等于true时作用是指Spring容器启动的时候不会去实例化这个bean, 而是在程序调用时才去实例化. 默认是false即Spring容器启动时实例化.

lazy-init设置为false有什么好处？
1）可以提前发现潜在的配置问题
2）Bean 对象存在于缓存中，使用时不用再去实例化bean，加快程序运行效率

prototype 作用域

通过scope="prototype" 设置bean的类型，每次向Spring容器请求获取Bean都返回一个全新的 Bean，相对于"singleton"来说就是不缓存Bean，每次都是一个根据Bean定义创建的全新Bean。

Web应用中的作用域

request作用域
表示每个请求需要容器创建一个全新Bean。比如提交表单的数据必须是对每次请求新建一个Bean
来保持这些表单数据，请求结束释放这些数据。
session作用域
表示每个会话需要容器创建一个全新Bean。比如对于每个用户一般会有一个会话，该用户的用户
信息需要存储到会话中，此时可以将该Bean作用域配置为session级别。
globalSession作用域
类似于session作用域，其用于portlet(Portlet是基于Java的Web组件，由Portlet容器管理，并由容
器处理请求，生产动态内容)环境的web应用。如果在非portlet环境将视为session作用域。

生命周期
在Spring中，Bean的生命周期包括Bean的定义、初始化、使用和销毁4个阶段与servlet的声明周期相似（不多介绍）

未完待续…

Spring框架①

Java相关栏目本月热门文章