Spring

简介

Spring 框架是以 interface21框架为基础吗,经过重新设计,并不断丰富其内涵,于2004年3月发布了1.0正式版
Spiring本身是一个大杂烩,整合了现有的技术框架。比如SSH, SSM
Spring是一个轻量级的、非入侵式的框架,核心是控制反转IOC和面向切面编程AOP,支持事务的处理和对框架的支持

组成

Spring 七大模块

IOC

理论推导

首先回顾一下传统的开发,就是一个接口就要有它对应的实现类,然后业务层要调用DAO层的代码,因为要拿到数据库的数据嘛对于业务层来说。
在我们之前的业务代码中,用户的需求可能会影响我们原来的代码,我们需要根据用户的需求取修改源代码。如果程序代码量很大,那么修改一次的成本就很高。

我们使用一个Set接口实现,已经发生了革命性的变化

之前,程序主动创建对象,控制权在程序员手上
使用了set注入之后,程序不再具有主动性,而是变成了被动的接受对象。

这种思想让程序员不用管理对象的创建,系统的耦合性降低,可以更加专注在业务的实现上,这是IOC的原型.

  1. UserDao接口
public interface UserDao {
    void getUser();
}

  1. UserDaoImpl 实现类

public class UserDaoImpl implements UserDao {

    @Override
    public void getUser() {
        System.out.println("默认获取用户的数据");
    }
}
  1. UserService 业务接口
public interface UserService {
    void getUser();
}
  1. UserServiceImpl 业务实现类
public class UserServiceImpl implements UserService {
    //业务层代码现在要调用dao的代码
    //这个地方的代码每一次需求变动,都得被修改
    private UserDao userDao;

    //现在我们加上一个set方法
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void getUser() {
        userDao.getUser();
    }
}
  1. 用户代码
public class MyTest {
    public static void main(String[] args) {

        //用户实际调用的是业务层,dao层他们不需要接触
//        UserService userService = new UserServiceImpl();
//        userService.getUser();

        // 现在需求来了,我要新增一个MysqlDao怎么办
        //这个时候我们就必须去改变业务层调用dao层的代码了

        UserService userService1 = new UserServiceImpl();
        //这里强转是因为setUserDao是子类独有的方法,父类没有
        ((UserServiceImpl) userService1).setUserDao(new UserDaoMysqlImpl());
        userService1.getUser();
    }
}

IOC 本质

控制反转IoC是一种设计思想,DI是实现IOC的一种方法。没有IOC的程序中,我们使用面向对象编程,对象的创建与对象间的依赖关系完全硬编码在程序中,对象的创建由程序自己控制,控制反转后将对象的创建转移给第三方,所谓控制反转就是:获得对象的方式反转了。
采用XML方式配置Bean的时候,Bean的定义信息是和实现分离的,而采用注解的方式可以把两者合为一体,Bean的定义信息直接以注解的形式定义在实现类中,从而达到了零配置的目的。

代码:HelloSpring
<!--    使用Spring来创建对象,在Spring中这些都称为Bean-->
<!--    如果我们这个实体类的set方法去掉,会直接报错-->
<!--    所以现在就是如果增加了实现类,其他代码都不变,只需要改这个配置文件就行了,然后-->
<!--    就直接去Spring容器拿对象-->
    <bean id="hello" class="com.lyle.pojo.Hello">
        <property name="str" value="Spring"/>
    </bean>

IOC创建对象的方式

  1. 无参构造创建对象,默认方式
  2. 有参构造:
  • 下标赋值
  • 通过类型
  1. 通过参数名赋值

    <!--    使用Spring来创建对象,在Spring中这些都称为Bean-->
    <!--    如果我们这个实体类的set方法去掉,会直接报错-->
    <!--    所以现在就是如果增加了实现类,其他代码都不变,只需要改这个配置文件就行了,然后-->
    <!--    就直接去Spring容器拿对象-->
<!--    <bean id="user" class="com.lyle.pojo.User">-->
<!--        无参构造-->
<!--        <property name="name" value="Lyle"/>-->
<!--        第一种:下标赋值-->
<!--        <constructor-arg index="0" value="Lyle"/>-->
<!--    </bean>-->

<!--    第二种方式:通过类型创建,不建议使用-->
    <bean id="user" class="com.lyle.pojo.User">
        <constructor-arg type="java.lang.String" value="Lyle"/>
    </bean>

<!--    第三种,直接通过参数名来设置-->
    <bean id="user" class="com.lyle.pojo.User">
        <constructor-arg name="name" value="Lyle"/>
    </bean>
</beans>

总结:在配置文件加载的时候,容器中管理的对象就已经初始化了。

Spring配置

别名

<alias name="user" alias="userNew"/>
name也是别名,而且name可以同时取多个别名
<bean id="userT" class="com.lyle.pojo.UserT" name="user2,u2">
</bean>

import
这个import,一般用于团队开发使用,他可以将多个配置文件,导入合并为一个
假设,现在项目中有多个人开发,这三个人负责不同的类开发,不同的类需要注册在不同的bean中,我们可以用import将所有人的beans.xml合并为一个总的

<import resource="beans.xml"/>
    <import resource="beans2.xml"/>
    <import resource="beans3.xml"/>

使用的时候,直接使用总的配置就可以了

依赖注入

构造器注入

前面已经说过了

set方式注入(重点)

代码:Spring-di

拓展方式

p和c命名空间

<!--    p命名空间注入 可以直接注入属性的值:property-->
    <bean id="user" class="com.lyle.pojo.User" p:name="Lyle" p:age="18"/>

<!--    c命名空间注入,通过构造器注入:construct-args-->
    <bean id="user2" class="com.lyle.pojo.User"  c:age="19" c:name="Lyle2"/>

Bean的作用域

singleton, prototype, 其他的request, session, application只能在web开发中使用到。

Bean的自动装配

自动装配是Spring满足bean依赖的一种方式,Spring会在上下文中自动寻找,并自动给bean装配属性

在Spring中有三种装配的方式

  1. 在xml中显示的配置
  2. 在java中显示配置
  3. 隐式的自动装配bean(重要)

测试环境搭建

public class MyTest {
    @Test
    public void test1() {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        People people = context.getBean("people", People.class);
        people.getDog().shout();
        people.getCat().shout();
    }
}

ByName和ByType自动装配

    <bean id="cat" class="com.lyle.pojo.Cat"/>
    <bean id="dog" class="com.lyle.pojo.Dog"/>

<!--    <bean id="people" class="com.lyle.pojo.People">-->
<!--        <property name="name" value="Lyle"/>-->
<!--        <property name="dog" ref="Dog"/>-->
<!--        <property name="cat" ref="cat"/>-->
<!--    </bean>-->

<!--    byname:会自动在容器上下文中查找,和自己对象set方法后面的值对应的beanid-->
<!--    byType会自动在容器上下文中查找,和自己对象属性类型相同的bean-->
<!--    <bean id="people" class="com.lyle.pojo.People" autowire="byType">-->
    <bean id="people" class="com.lyle.pojo.People" autowire="byName">
        <property name="name" value="Lyle"/>
    </bean>

使用注解实现自动装配

JDK1.5支持注解,Spring2.5支持注解。
要使用注解须知:

  1. 导入约束:context约束
  2. 配置注解的支持:context:annotation-config/
<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

<!--    开启注解支持-->
    <context:annotation-config/>
</beans>

@Autowired
直接在属性上使用即可!也可以在set方法上使用。
使用@Autowired 我们可以不写set方法了,前提是这个自动装配属性在IOC容器中存在,且符合名字byName.
科普:
@Nullable 字段标注了这个注解,说明这个字段可以为null
如果显式定义了Autowired 的required属性为false,说明这个对象可以为null,否则不允许为空

如果@Autowired 自动装配的环境比较复杂,自动装配无法通过一个注解完成的时候,我们可以使用@Qualifier(value="xxx")去配置@Autowired的使用,指定一个唯一的bean对象注入

@Resource注解

public class People {
  @Resource(name = "cat2")
  private Cat cat;

  @Resource
  private Dog dog;
}

@Resource和@Autowired的区别:

  • 都是用来自动装配的,都可以放在属性字段上
  • @Autowired 通过byName的方式实现
  • @Resource 默认通过byName的方式实现,如果找不到名字,则通过byType实现。如果两个都找不到的情况下,就报错。
  • 执行顺序不同:@Autowired通过byType的方式实现 @Resource默认通过byName的方式实现

使用注解开发

@Component:组件,放在类上,说明这个类被Spring管理了,就是bean

属性如何注入

@Component
public class User {
//    public String name = "Lyle";
    @Value("Lyle")
    public String name;
    
    @Value("Lyle")
    public void setName(String name) {
        this.name = name;
    }
}

@Component有几个衍生注解,我们在web开发中,会按照mvc三层架构分层

小结:

  • xml更加万能,维护简单方便
  • xml用来管理bean
  • 注解只负责属性的注入

静态代理

代理模式的好处:

  • 可以使真实角色的操作更加纯粹,不用去关注一些公共的业务
  • 公共业务交给代理角色,实现了业务的分工
  • 公共业务发生扩展的时候,方便集中管理
  • 一个动态代理代理的是一个接口,一般就是对应的一类业务
  • 一个动态代理类可以代理多个类,只要是实现了同一个接口

缺点:

  • 一个真实角色就会产生一个代理角色,代码量会翻倍,开发效率会变低

动态代理

  • 动态代理和静态代理角色一样
  • 动态代理的代理类是动态生成的,不是我们直接写好的
  • 动态代理分为两类:基于接口的动态代理和基于类的动态代理
    • 基于接口 -- JDK动态代理
    • 基于类: cglib
    • Java字节码

AOP

AOP意为:面向切面编程
AOP其实就是为了代码复用并降低模块之间的耦合,代码也更好维护,也能集中管理非业务代码。

Spring的构造型注解

来自Spring实战5一书,提到 @Repository, @Controller,@Component都是构造型注解,应该是指这些注解标记的类会被Spring接管并初始化为容器(Spring上下文)中的bean,

posted @ 2022-01-05 13:09  Lylee  阅读(27)  评论(0编辑  收藏  举报