笑着学Spring - (1)_学spring一定要笑着-CSDN博客

Aspect Oriented Programming , 通过 Spring 提供的 AOP 功能，方便进行面向切面的编程，许多不容易用传统 OOP 实现的功能可以通过 AOP 轻松应付在 Spring 中，开发人员可以从繁杂的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量.

一站式

Spring 本身也提供了数据访问功能和 web 功能,以及可以很好的管理其他框架.

搭建你的第一个Spring实例

首先第一步, 在maven中导入spring的核心jar

<!-- spring-context --> 
<dependency> 
   <groupId>org.springframework</groupId>
   <artifactId>spring-context</artifactId> 
   <version>5.2.2.RELEASE</version> 
</dependency>

可以在maven里看到 spring 核心包的jar依赖关系

写一个User类

public class User {
   
    public User(){System.out.println("无参构造");}
}

在resources目录下新建 spring.xml 配置文件

<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
      
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--配置我们需要让spring管理的类 , 创建对象-->
    <!--由spring创建的对象我们称为一个bean-->
    <!--id : 生成对象的标识, class : 全类名-->
    <bean id="user" class="com.ff.spring.bean.User">
 
    </bean> 
</beans>

//ApplicationContext是spring底层的一个接口,定义了一些规范,负责实例化,配置,组装bean
//ClassPathXmlApplicationContext是一个具体的实现类,创建并管理对象
ApplicationContext app = new ClassPathXmlApplicationContext("spring.xml");
User user=app.getBean("user",User.class);
System.out.println(user)

IOC(控制反转)

读作 “反转控制”(Inverse of Control) 更好理解，不是什么技术，而是一种 设计思想 ，就是 将原本在程序中手动创建对象的控制权，交由 Spring 框架来 管理。

正控：若要使用某个对象，需要自己去负责对象的创建

反控：若要使用某个对象，只需要从 Spring 容器中获取需要使用的对象,不关心对象的创建过程，也就是把创建对象的控制权反转给了 Spring 框架 .

这样做有什么好处呢?

IOC 容器是具有依赖注入功能的容器 , 负责对象的一系列操作, 我们把创建对象的控制权交给spring , 当我们需要的时候直接去容器获取, 不需要考虑类与类之间的依赖, 降低了耦合度

底层实现方式: 解析 xml/扫描注解标签 + 工厂模式 + 反射机制

Spring Bean 管理 ( 基于 xml 配置方式)

我们在dao层先定义方法

public class UserDao {
    public void saveUser(){
        System.out.println("保存");
    }
}

service层 :

public class UserService {
    private UserDao userDao;
    public void save(){
        userDao.saveUser();
    }

    public UserDao getUserDao() {
        return userDao;
    }

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

在 spring.xml文件中配置依赖关系

<bean id="userDao" class="com.ff.spring.dao.UserDao"/>
    <bean id="userService" class="com.ff.spring.Service.UserService">
        <!--ref代表引用的类-->
        <property name="userDao" ref="userDao"/>
    </bean>

ApplicationContext app = new ClassPathXmlApplicationContext("spring.xml");

UserService userService=app.getBean("userService",UserService.class);

userService.save();

通过上述代码可以看出 , userDao 依赖于 userService , 我们需要去配置这个依赖关系

Xml 配置方式依赖注入【DI：Dependency Injection】

就是说, 我们可以在创建对象的同时,直接为属性注入值

这里有两种方式 :

1. 通过构造方法 2. 通过set方法

public class User {
    private Integer num;
    private String account;
    private String password;
    private List<Integer> list;
    public User() {
        System.out.println("无参");
    }

    public User(Integer num, String account, String password) {
        this.num = num;
        this.account = account;
        this.password = password;
    }

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

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

    public Integer getNum() {
        return num;
    }

    public void setNum(Integer num) {
        this.num = num;
    }

    public String getAccount() {
        return account;
    }

    public void setAccount(String account) {
        System.out.println("vfdsv");
        this.account = account;
}

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
    
}

完善上面的 User 类

<!--通过构造方法注入-->
    <bean id="user1" class="com.ff.spring.model.User">
        <constructor-arg name="account" value="张三"/>
        <constructor-arg name="password" value="123"/>
        <constructor-arg name="num" value="1"/>
    </bean>
    <!--通过set方法注入-->
    <bean id="user2" class="com.ff.spring.model.User">
        <property name="account" value="jim"/>
        <property name="password" value="789"/>
        <property name="num" value="1"/>
        <property name="list">
            <list>
                <value>1</value>
                <value>2</value>
                <value>3</value>
            </list>
        </property>
    </bean>

注入的两种方式如上

我们说框架的存在就是为了简化开发,那这样一直配置不也很麻烦吗?

所以这里我们引入注解注入的方式

注解

在spring.xml中开启注解扫描

<context:component-scan base-package="包名"> </context:component-scan>

注解创建对象

@Component(value=“user”) 等于 <bean id=“user” class=“”></bean>

@Service //逻辑处理层

@Repository //数据访问层

@Autowired

@Autowired 是 Spring 提供的注解,可以写在字段和 setter 方法上。如果写在字段上，那么就不需要再写 setter 方法。默认情况下它要求依赖对象必须存在，如果允许 null 值，可以设置它required 属性为 false。

例如 :

我们可以这样, 直接将这个属性注入进来

但是需要注意, 我们上述注入的时候 , BookService类上需要加@Service , BookDao类需要加@Repository , 加注解表明交给spring管理,不加则扫描不到依赖关系

byType 自动注入

该注解默认使用按类型自动装配 Bean 的方式。

可以通过类型注入, 也可以通过name注入

byName 自动注入

如果我们想使用按照名称（byName）来装配，可以结合@Qualifier 注解一起使用。

需要在引用属性上联合使用注解@Autowired 与@Qualifier。@Qualifier 的

value 属性用于指定要匹配的 Bean 的 id 值。

JDK 注解@Resource 自动注入

S pring 提供了对 jdk 中@Resource 注解的支持。@Resource 注解既可以按名称匹配 Bean，也可以按类型匹配 Bean。默认按照 ByName 自动注入

结语

关于spring今天就先谈到这里, 后面再来介绍AOP和事务管理这些内容,谢谢阅读😊