Spring--01

Spring 1.Spring概念

1.1 Spring框架的概述概述：

Spring 是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。任何 Java 应用都可以从 Spring 中受益。Spring 的核心是控制反转（IOC）和面向切面（AOP）。简单来说，Spring 是一个分层的 JavaSE/EE full-stack(一站式) 轻量级开源的Java EE框架。

IOC：控制反转，把创建对象过程交给Spring进行管理
AOP：面向切面，在不修改源代码的情况下，进行源代码的功能增强

特点：

方便解耦，简化开发
AOP编程的支持
方便程序的测试
方便集成各种优秀的框架
方便进行事务操作
降低API的使用难度

1.2 Hello Spring

文件结构：

1.首先新建一个maven项目

2.在maven项目中导入spring依赖


    org.springframework
    spring-context
    5.3.9

3.创建一个简单的JavaBean

package com.spring.pojo;

public class User {
    private String name;
    private String id;

    public User() {
    }

    public String getName() {
        return name;
    }

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

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

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

4.编写xml配置文件beans1.xml

5.编写测试类

package testdemo;

import com.spring.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class testSpring5 {
    @Test
    public void testUser(){
        //1.加载spring的配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("beans1.xml");
        //2.获取配置创建的对象
        User user = context.getBean("user", User.class);
        user.setId("1");
        user.setName("张三");
        System.out.println(user);

    }
}
//输出结果：
//User{name='张三', id='1'}

2.IoC容器

2.1 IoC底层原理 IoC概述

什么是IoC？

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。

控制反转，把对象创建和对象之间的调用过程，交给spring进行管理。
使用IoC的目的：为了降低耦合度

Ioc底层原理

应用的技术：xml解析、工厂模式、反射

底层原理的实现：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lfOOUnbS-1634560662323)(D:/Java/note/image-20211018103242084.png)]

2.2 IoC接口

IoC思想基于 IoC容器完成，IoC容器底层就是对象工厂。
Spring提供IoC容器实现两种方式：（两个接口）
1. **BeanFactory：**IoC容器的最基本实现，是Spring内部使用接口，一般不使用。
  
  加载配置文件的时候不会创建对象，只是在获取（使用）的时候才会创建对象
2. **ApplicationContext：**BeanFactory接口的子接口，提供更多更强大的功能，一般使用ApplicationContext。
  
  加载文件的时候就创建对象。
ApplicationContext接口的实现类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8FSmva74-1634560662334)(D:/Java/note/image-20211018104406508.png)]

2.3 IoC操作Bean管理

什么是Bean管理？

Bean管理是指两个操作
Spring创建对象
Spring注入属性

Bean管理操作的两种方式

基于xml配置文件的方式实现
基于注解方式实现

2.3.1 基于xml方式创建对象：

在Spring配置文件中，使用bean标签，标签里面添加对应的属性，就可以实现对象创建。
常用的bean标签属性：
创建对象的时候，默认执行无参构造，完成对象的创建。

基于xml方式注入属性

DI：依赖注入，就是注入属性

set方式（原始方式）

创建属性和set方法

public class Book {

    //创建属性
    private String bname;

    public String getBname() {
        return bname;
    }
    //创建属性对应的set方法
    public void setBname(String bname) {
        this.bname = bname;
    }
    
}

在spring配置文件中配置对象的创建，配置属性注入。
```
    
    
```

测试：

@Test
public void testBook(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans1.xml");
    Book book = context.getBean("book", Book.class);
    System.out.println(book.getBname());
    //平凡的世界
}

通过有参构造

创建属性

创建有参构造

public class Order {
    private String oName;
    private String address;

    public Order(String oName, String address) {
        this.oname = oName;
        this.address = address;
    }

    @Override
    public String toString() {
        return "Order{" +
                "oname='" + oname + ''' +
                ", address='" + address + ''' +
                '}';
    }
}

有参构造注入属性
```
    
    
```

测试

@Test
public void testOrder(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans1.xml");
    Order order = context.getBean("order", Order.class);
    System.out.println(order);
    //Order{oname='电脑', address='China'}
}

p名称空间注入：简化xml配置方式
- 添加p名称空间在配置文件中 xmlns:p=“http://www.springframework.org/schema/p”
- 进行属性注入，在bean标签中进行操作

xml注入其他类型属性

向属性中注入null值使用null标签

@Test
public void testNull(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans1.xml");
    Book book = context.getBean("book2", Book.class);
    System.out.println(book.getBname());
    //null
}

向属性中注入特殊符号

]]>

@Test
public void testCDATA(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans1.xml");
    Book book = context.getBean("book3", Book.class);
    System.out.println(book.getBname());
    //<自在独行>
}

注入属性：外部Bean

创建两个类service类、dao类

在service层中调用dao层

public class UserService {
    //创建UserDAO类型属性，生成set方法，通过调用set方法实现注入
    private UserDAO userDAO;

    public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
    }

    public void add(){
//        //原始方式
//        UserDAO dao = new UserDAOImpl();
//        dao.update();
        System.out.println("service add————————");
        userDAO.update();
    }
}
public interface UserDAO {
    public void update();
}
public class UserDAOImpl implements UserDAO{
    @Override
    public void update() {
        System.out.println("dao update————————");
    }
}

在spring配置文件中进行配置

测试：

 @Test
    public void test1(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans2.xml");
        UserService bean = context.getBean("userService", UserService.class);
        bean.add();
//        service add————————
//        dao update————————
    }

注入属性-内部Bean

一对多关系：部门和员工

public class Dept {
    private String dName;

    public void setdName(String dName) {
        this.dName = dName;
    }
}

public class Emp {
    private String ename;
    private String gender;
    private Dept dept;

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }


    public void setGender(String gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "ename='" + ename + ''' +
                ", gender='" + gender + ''' +
                ", dept=" + dept +
                '}';
    }
}
@Test
public void test2(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans2.xml");
    Emp emp = context.getBean("emp", Emp.class);
    System.out.println(emp);
    //Emp{ename='张三', gender='男', dept=com.spring.pojo.Dept@2767e23c}
}

注入属性-级联赋值

第一种方法

@Test
public void test2(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans2.xml");
    Emp emp = context.getBean("emp1", Emp.class);
    System.out.println(emp);
    //Emp{ename='张三', gender='男', dept=Dept{dName='财务部'}}
}

第二种方法
```
    
    
    
    


    
```

xml注入集合属性

数组类型
List集合
Map集合

Set集合

创建类，定义相关类型的属性

public class Stu {
    //数组类型
    private String[] courses;

    //list集合
    private List list;

    //map集合
    private Map maps;

    //set集合
    private Set set;

    public void setCourses(String[] courses) {
        this.courses = courses;
    }

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

    public void setMaps(Map maps) {
        this.maps = maps;
    }

    public void setSet(Set set) {
        this.set = set;
    }
}

在spring配置文件中配置

测试

@Test
    public void test1(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans1.xml");
        Stu stu = context.getBean("stu", Stu.class);
        System.out.println(Arrays.toString(stu.getCourses()));
        //遍历list
        stu.getList().forEach(System.out :: println);
        //遍历map
        System.out.println(stu.getMaps());
        //遍历set
        stu.getSet().forEach(System.out :: println);
//        [java, c, python]
//        甲
//        乙
//        丙
//        {JAVA=java, PYTHON=python}
//        1
//        2
//        3
    }

在集合中设置对象类型的值

在list标签中嵌套一个ref标签属性bean的值是对象的bean

把集合注入部分提取出来

在spring中引入名称空间util

使用util标签做到提取集合属性注入


    
    



    hello1
    hello2
    hello3

2.3.2 IoC操作Bean管理（FactoryBean）

Spring中有两种类型的Bean一种普通的Bean，另外一种工厂Bean（FactoryBean）

普通Bean：定义什么类型就返回什么类型

FactoryBean：返回类型不一定是定义类型

创建类，让这个类作为工厂Bean实现FactoryBean

实现接口里面的方法，在实现的方法中定义返回的类型

public class MyBean implements FactoryBean{
    //定义返回的类型
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCourse("abc");
        return course;
    }

    @Override
    public Class getObjectType() {
        return null;
    }
}

2.3.3 bean的作用域

spring一般默认属性为单实例
scope属性值
- 默认为singleton：单实例对象
- prototype：多实例对象
- singleton和prototype的区别：singleton在加载配置文件的时候就会生成单实例对象，prototype在调用getBean方法的时候才会创建对象。

2.3.4 bean的生命周期

通过构造器创建bean实例（无参数构造）
为bean的属性设置值和对其他bean的引用（调用set方法）
调用bean的初始化的方法
得到bean
当容器关闭的时候，调用bean销毁的方法。

测试生命周期：

public class Orders {
    public Orders() {
        System.out.println("1.执行无参构造创建bean实例");
    }

    private String oname;

    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("2. 调用set方法设置值");
    }

    //创建执行的初始化方法
    public void initMethod(){
        System.out.println("3. 执行初始化的方法");
    }

    //销毁执行的方法
    public void destroyMethod(){
        System.out.println("5. 执行销毁的方法");
    }

}

@Test
public void testBean(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans2.xml");
    Orders orders = context.getBean("orders", Orders.class);
    System.out.println("4. 获取到创建bean的实例");
    System.out.println(orders);

    //手动让bean的实例销毁
    context.close();
    //        1.执行无参构造创建bean实例
    //        2. 调用set方法设置值
    //        3. 执行初始化的方法
    //        4. 获取到创建bean的实例
    //        com.spring.bean.Orders@742ff096
    //        5. 执行销毁的方法
}

bean的后置处理：

通过构造器创建bean实例（无参数构造）
为bean的属性设置值和对其他bean的引用（调用set方法）
把bean实例传递bean后置处理器的方法
调用bean的初始化的方法
把bean实例传递bean后置处理器的方法
得到bean
当容器关闭的时候，调用bean销毁的方法。

public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之前执行的方法");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之后  执行的方法");
        return bean;
    }
}

2.3.5 自动装配

自动装配：根据指定装配规则（属性名称或者属性类型），Spring自动将匹配的属性值进行注入。

自动装配过程：

2.3.6 外部属性文件

引入依赖
创建配置文件
增加内部空间
引入依赖使用el表达式

2.3.7 IoC基于注解方式管理Bean

注解：代码中的特殊标记 @注解名称（属性名称=属性值…）

创建对象的注解：以下注解的功能是一样的，都用来创建bean实例

@Component
@Service
@Controller
@Repository

基于注解方式实现对象创建

引入依赖


    org.springframework
    spring-aop
    5.3.10

开启组件扫描
注意：
```
    
    




    
```

创建类，在类上面添加创建对象的注解

package com.spring.service;

import org.springframework.stereotype.Component;

//在注解里面value可以省略不写，默认是类名称首字母小写
@Component(value = "userService")//
public class UserService {
    public void add(){
        System.out.println("service add _____");
    }
}

测试：

public class testDemo1 {
    @Test
    public void testService(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans1.xml");

        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
//        service add _____
    }
}

基于注解方式实现属性的注入

@AutoWired：根据属性类型进行自动装配
@Qualifier：根据属性名称进行注入（要配合@AutoWired一起使用）
@Resource：可以根据类型注入，也可以根据名称注入
@Value：注入普通类型属性

注入步骤：

创建相应的类并添加注解

@Repository
public class UserDaoImpl implements UserDao{
    @Override
    public void add() {
        System.out.println("dao add+++++++++++++");
    }
}

在service中注入dao对象，添加相关属性，并在属性上面使用注解。

@Service
public class UserService {
    //定义dao类型属性
    //可以不添加set方法
    @Autowired
    private UserDao userDao;

    public void add(){
        System.out.println("service add _____");
        userDao.add();
    }
}

根据名称注入：@Qualifier：根据属性名称进行注入（要配合@AutoWired一起使用）

@Service
public class UserService {
    //定义dao类型属性
    //可以不添加set方法
    @Autowired
    //根据名称注入
    @Qualifier(value = "userDaoImpl")
    private UserDao userDao;

    public void add(){
        System.out.println("service add _____");
        userDao.add();
    }
}

@Resource：可以根据类型注入，也可以根据名称注入

@Service
public class UserService {
    //根据类型注入
    @Resource(name = "userDaoImpl")//根据名称注入
    private UserDao userDao;

    public void add(){
        System.out.println("service add _____");
        userDao.add();
    }
}

@Value：注入普通类型属性

@Service
public class UserService {
    @Value(value = "abc")
    private String name;

    public void add(){
        System.out.println("service add _____");
        System.out.println(name);
    }
}

2.3.8 纯注解开发（完全注解开发）

创建配置类，替代xml配置文件

package com.spring.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration//作为配置类，替代xml配置文件
@ComponentScan(basePackages = {"com.spring"})
public class SpringConfig {

}

编写测试类

@Test
public void testService2(){
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
    UserService userService = context.getBean("userService", UserService.class);
    userService.add();
}

Spring--01

Java相关栏目本月热门文章