文章目录

spring简介
IOC控制反转
- ioc概念
- ioc使用
- - （1）导入依赖
  - （2）编写实体类
  - （3）编写配置文件
  - （3）创建容器从容器中获取对象并测试
- ioc三种创建对象方式
- - （1）下标赋值
  - （2）类型创建
  - （3）参数名
DI依赖注入
- 构造器注入
- Set方法注入
- (c,p)命名注入
bean的作用域
bean的自动装配
- ByName自动装配
- ByType自动装配
- 使用注解实现自动装配
Spring注解开发
- 脱离spring的xml配置，纯注解开发
AOP底层:代理模式
- 静态代理
- 动态代理
Aop概念
- Spring实现Aop
- - 使用Spring的API接口
  - 自定义来实现AOP
  - 注解实现AOP

spring简介

spring是一个轻量级开源框架，是为了解决企业应用程序开发复杂性创建的

spring目前是JavaEE开发的灵魂框架。他可以简化JavaEE开发,可以非常方便整合其他框架，无侵入的进行功能增强。

spring的核心是控制反转(IOC)和面向切面(AOP)。

IOC控制反转

ioc概念

spring ioc控制反转，对象之间的依赖交给sping来进行管理，避免了强耦合；

ioc使用

（1）导入依赖

导入SpringIOC相关依赖

        <dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.3.6</version></dependency>

（2）编写实体类

路径自己建立

public class User {private String name;public User() {}public User(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "User{" +"name='" + name + '\'' +'}';}
}

（3）编写配置文件

在resources目录下创建applicationContext.xml文件，文件名可以任意取。但是建议叫applicationContext。

内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"><!--classs:配置类的全类名id:配置一个唯一标识property 相当于给对象中的属性设置一个值！--><bean id="user" class="com.guohui.pojo.User"><property name="name" value="国辉"/></bean></beans>

（3）创建容器从容器中获取对象并测试

public class MyTest {public static void main(String[] args) {//创建对象ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");//获取对象User user = (User) context.getBean("user");System.out.println(user);}
}

ioc三种创建对象方式

····使用无参构造创建对象，默认！
····假设我们要使用有参构造创建对象。

（1）下标赋值

<!--第一种方式：下标赋值    --><bean id="user" class="com.guohui.pojo.User"><constructor-arg index="0" value="国辉"/></bean>

（2）类型创建

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

（3）参数名

<!--第三种方式：直接通过参数名来设置    --><bean id="user" class="com.guohui.pojo.User"><constructor-arg name="name" value="国辉"/></bean>

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

DI依赖注入

构造器注入

使用有参构造进行注入

    <bean id="user" class="com.guohui.pojo.User"><constructor-arg type="java.lang.String" value="guohui"/></bean>

Set方法注入

依赖：bean对象的创建依赖于容器！
注入：bean对象中的所有属性,由注入器来注入

<!--classs:配置类的全类名id:配置一个唯一标识property 相当于给对象中的属性设置一个值！
--><bean id="user" class="com.guohui.pojo.User"><property name="name" value="国辉"/></bean>

(c,p)命名注入

注意点：p命名和c命名空间不能直接使用，需要导入xml约束！

       xmlns:p="http://www.springframework.org/schema/p"xmlns:c="http://www.springframework.org/schema/c"

了解就行了，不推荐使用！

bean的作用域

单例模式（Spring默认机制）scope=“singleton”
原型模式：每次从容器中get的时候，都会产生一个新对象！scope=“prototype”

其余的request、session、application、这些只能在web开发中使用到！

bean的自动装配

自动装配是spring满足bean依赖的一种方式！

Spring会在上下文中自动寻找，并自动给bean装配属性！

在Spring中有三种装配的方式：

ByName的时候，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致！
ByType的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性的类型一致！

ByName自动装配

        <!--byName：会自动在容器上下文中查找，和自己对象set方法后面的值对应的bean id！-->
<bean id="people" class="com.kuang.pojo.People" autowire="byName"><property name="name" value="小白莲"/>
</bean>

ByType自动装配

        <!--byType：会自动在容器上下文中查找，和自己对象属性类型相同的bean！--><bean id="people" class="com.kuang.pojo.People" autowire="byType"><property name="name" value="小白莲"/></bean>

使用注解实现自动装配

@Autowired注解

注解开发准备工作
如果要使用注解开发必须要开启组件扫描，这样加了注解的类才会被识别出来。Spring才能去解析其中的注解。

   导入约束xmlns:context="http://www.springframework.org/schema/context"

xml
<!--启动组件扫描，指定对应扫描的包路径，该包及其子包下所有的类都会被扫描，加载包含指定注解的类-->
<context:component-scan base-package="com.guohui"/>

<?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 http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"><!--  启动组件扫描--><context:component-scan base-package="com.guohui"/><bean id="cat" class="com.guohui.pojo.Cat"/><bean id="dog" class="com.guohui.pojo.Dog"/><bean id="people" class="com.guohui.pojo.People"></bean></beans>

@Autowired注解
直接在属性上使用即可！

public class People {@Autowiredprivate Cat cat;@Autowiredprivate Dog dog;private String name;@Overridepublic String toString() {return "People{" +"cat=" + cat +", dog=" + dog +", name='" + name + '\'' +'}';}public Cat getCat() {return cat;}public void setCat(Cat cat) {this.cat = cat;}public Dog getDog() {return dog;}public void setDog(Dog dog) {this.dog = dog;}public String getName() {return name;}public void setName(String name) {this.name = name;}
}

Spring注解开发

bean


@Component//相当于 <bean id ="user" class="com.guohui.dao.User"/>public class User {//相当于  <property name="name" value="guohui"/>@Value("guohui")public String name;//相当于  <property name="name" value="666666"/>@Value("666666")public String pwd;}

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

dao 【@Repository】
service 【@Service】
controller 【@Controller】

自动装配

- @Autowired：自动装配通过类型，名字。如果Autowired不能唯一自动装配上属性，则需要通过@Qualifier(value = "xxx")去配置。
- @Nullable 字段标记了了这个注解，说明这个字段可以为null;
- @Resource：自动装配通过名字，类型。

脱离spring的xml配置，纯注解开发

@Component
public class User {private String name;@Value("纯注解")public void setName(String name) {this.name = name;}public User() {}@Overridepublic String toString() {return "User{" +"name='" + name + '\'' +'}';}public String getName() {return name;}public User(String name) {this.name = name;}
}

配置文件applicationContext.xml

// 这个也会Spring容器托管，注册到容器中，因为它本来就是一个@Component
// @Configuration代表这是一个配置类，就和我们之前看的applicationContext.xml文件
@Configuration
@ComponentScan("com.guohui.pojo")//启动注解扫描
@Import(GuoConfig.class)//引入多个@Configuration相当于引入多个applicationContext.xml文件
public class GuoConfig {//注册一个bean。相当于applicationContext.xml文件里的bean标签//这个方法的名字就是bean中的id属性//这个方法返回的值相当于，bean标签中的class属性@Beanpublic User getUser(){return new User();}
}

测试类

public class demo {public static void main(String[] args) {//如果完全使用了配置类方式去做，我们就只能通过 AnnotationConfig 上下文来获取容器，通过配置类的class对象加载！AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(GuoConfig.class);User getUser = (User) context.getBean("getUser");System.out.println(getUser.getName());}
}

AOP底层:代理模式

静态代理

角色分析：
抽象角色：一般使用接口或者抽象类来解决
真实角色：被代理的角色
代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
客户：访问代理对象的人！

代码案例
想恋爱的男孩

//单生狗要找对象
public class boy {public static void main(String[] args) {//男生恋爱找媒人就行了，媒人就相当于代理模式Proxy proxy = new Proxy();proxy.like();//媒人帮忙必收好，a方法收钱，b方法蹭饭proxy.a();proxy.b();}
}

女人

//女人----要恋爱
public class girl implements like{@Overridepublic void like() {System.out.println("女孩要恋爱！！！");}
}

成双结对-恋爱

//恋爱-在一起
public interface like {public void like();
}

媒人-(代理模式)

//媒人
public class Proxy implements like {private girl girl;public Proxy() {}public com.guohui.demo_01.girl getGirl() {return girl;}public void setGirl(com.guohui.demo_01.girl girl) {this.girl = girl;}@Overridepublic void like() {System.out.println("帮女孩恋爱");}public void a() {System.out.println("收中介费用");}public void b() {System.out.println("吃席");}
}

代理模式的好处：

1、代理模式能将代理对象与真实被调用的目标对象分离。
2、一定程度上降低了系统的耦合度，扩展性好。
3、可以起到保护目标对象的作用。
4、可以对目标对象的功能增强。

代理模式的坏处：

 1、代理模式会造成系统设计中类的数量增加。2、在客户端和目标对象增加一个代理对象，会造成请求处理速度变慢。3、增加了系统的复杂度。

动态代理

动态代理底层是反射

动态代理和静态代理角色一样
动态代理的代理类是动态生成的，不是我们直接写好的！
动态代理分为两大类：基于接口的动态代理，基于类的动态代理

动态代理基于接口：jdk动态代理
需要了解两个类：Proxy：代理；InvocationHandler：调用处理程序。

动态代理的好处：

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

Aop概念

Spring 面向切面编程（Aop）
面向切面的编程，或AOP，是一种编程技术，对业务逻辑中的各个部分切割隔离，使耦合度降到最低，不仅增加了开发效率，还增强了系统的重用性和可维护性。

Spring实现Aop

使用AOP织入，需要导入一个依赖包

        <dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.6</version></dependency>

使用Spring的API接口

使用注解简单

自定义来实现AOP