Spring5快速入门，一文贯穿

最新推荐文章于 2022-03-13 19:51:31 发布

Zero-c

最新推荐文章于 2022-03-13 19:51:31 发布

阅读量181

点赞数

分类专栏： #Spring 框架业务层

本文链接：https://blog.csdn.net/weixin_45763051/article/details/118698279

版权

框架同时被 3 个专栏收录

2 篇文章 0 订阅

订阅专栏

#Spring

1 篇文章 0 订阅

订阅专栏

业务层

1 篇文章 0 订阅

订阅专栏

Spring5快速入门，一文贯穿

轻量级开源j2ee应用开发程序

特点：

方便解耦
支持aop
方便程序测试
方便整合框架
降低api开发难度
方便事务操作

IOC 控制反转

把创建对象过程交给spring进行管理，降低耦合度

底层原理

xml解析、工厂模式、反射

过程：

使用xml创建对象
使用xml解析技术解析
通过反射创建对象
- Class clazz = Class.forName(解析出来的class路径)；
- return (类名)clazz.newInstance();

IOC容器底层就是对象工厂

spring提供IOC容器实现的两种方式（两个接口）：

1.BeanFactory: （加载配置文件的时候不会创建对象，使用的时候才创建对象）

IOC容器基本实现方式，是spring内部使用的接口，不提供开发人员使用

2.ApplicationContext（加载配置文件的时候就创建对象）

是beanfactory的子接口，提供更多工能，供开发人员使用。

实现类：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xkK0axEE-1626155346282)(…/…/AppData/Roaming/Typora/typora-user-images/image-20210712180533330.png)]

Bean管理

基于xml方式

创建对象

（1）bean标签

id：全局唯一标识

class：类全路径

属性注入

set方法注入

<!--（2）spring方式： set方法注入属性-->
<bean id="book" class="com.zero.spring5.Book">
    <!--使用property完成属性注入
        name：类里面属性名称
        value：向属性注入的值
    -->
    <property name="bname" value="Hello"></property>
    <property name="bauthor" value="World"></property>
</bean>

有参构造

<!--（2）spring方式：有参数构造注入属性-->
<bean id="orders" class="com.atguigu.spring5.Orders">
    <constructor-arg name="oname" value="Hello"></constructor-arg>
    <constructor-arg name="address" value="China！"></constructor-arg>
</bean>

注入空值

<bean id="book" class="com.atguigu.spring5.Book">
    <!--（1）null值-->
    <property name="address">
        <null/><!--属性里边添加一个null标签-->
    </property>
    
    <!--（2）特殊符号赋值-->
     <!--属性值包含特殊符号
       a 把<>进行转义 &lt; &gt;
       b 把带特殊符号内容写到CDATA
      -->
        <property name="address">
            <value><![CDATA[<<南京>>]]></value>
        </property>
</bean>

注入外部Bean

<!--1 service和dao对象创建-->
<bean id="userService" class="com.zero.spring5.service.UserService">
    <!--注入userDao对象
        name属性：类里面属性名称
        ref属性：创建userDao对象bean标签id值
    -->
    <property name="userDao" ref="userDaoImpl"></property>
</bean>
<bean id="userDaoImpl" class="com.zero.spring5.dao.UserDaoImpl"></bean>

注入内部类和级联赋值

<!--内部bean-->
    <bean id="emp" class="com.zero.spring5.bean.Emp">
        <!--设置两个普通属性-->
        <property name="ename" value="Andy"></property>
        <property name="gender" value="女"></property>
        <!--设置对象类型属性-->
        <property name="dept">
            <bean id="dept" class="com.zero.spring5.bean.Dept"><!--内部bean赋值-->
                <property name="dname" value="宣传Fehead"></property>
            </bean>
        </property>
    </bean>

<!--方式一：级联赋值-->
    <bean id="emp" class="com.zero.spring5.bean.Emp">
        <!--设置两个普通属性-->
        <property name="ename" value="Andy"></property>
        <property name="gender" value="女"></property>
        <!--级联赋值-->
        <property name="dept" ref="dept"></property>
    </bean>
    <bean id="dept" class="com.zero.spring5.bean.Dept">
        <property name="dname" value="公关Fehead"></property>
    </bean>

 <!--级联赋值-->
    <bean id="emp" class="com.zero.spring5.bean.Emp">
        <!--设置两个普通属性-->
        <property name="ename" value="jams"></property>
        <property name="gender" value="男"></property>
        <!--级联赋值-->
        <property name="dept" ref="dept"></property>
        <property name="dept.dname" value="技术Fehead"></property>
    </bean>
    <bean id="dept" class="com.zero.spring5.bean.Dept">
    </bean>

注入集合属性

<!--（2）在 spring 配置文件进行配置-->
    <bean id="stu" class="com.zero.spring5.collectiontype.Stu">
        <!--数组类型属性注入-->
        <property name="courses">
            <array>
                <value>java课程</value>
                <value>数据库课程</value>
            </array>
        </property>
        <!--list类型属性注入-->
        <property name="list">
            <list>
                <value>张三</value>
                <value>李四</value>
            </list>
        </property>
        <!--map类型属性注入-->
        <property name="maps">
            <map>
                <entry key="JAVA" value="java"></entry>
                <entry key="Python" value="php"></entry>
            </map>
        </property>
        <!--set类型属性注入-->
        <property name="sets">
            <set>
                <value>MySQL</value>
                <value>Redis</value>
            </set>
        </property>
</bean>

注入对象类型集合

    <!--创建多个course对象-->
    <bean id="course1" class="com.zero.spring5.collection.Course">
        <property name="cname" value="Spring5框架"></property>
    </bean>
    <bean id="course2" class="com.zero.spring5.collection.Course">
        <property name="cname" value="MyBatis框架"></property>
    </bean>
    
   	<!--注入list集合类型，值是对象-->
       <property name="courseList">
           <list>
               <ref bean="course1"></ref>
               <ref bean="course2"></ref>
           </list>
       </property>

FactoryBean

spring中有两种类型的bean，一种是普通的bean，一种是FactoryBean

普通的Bean：在配置文件中定义的bean类型就是返回类型
工厂Bean：在配置文件定义bean类型可以和返回的类型不一样

public class MyBean implements FactoryBean<User>{
    @Override
    public Object getObject() throws Exception {
        return null;
    }
    @Override
    //确定返回的类型
    public Class<?> getObjectType() {
        User t = new User(){{
            setId(1);
        }}
        return t;
    }
    @Override
    public boolean isSingleton() {
        
    }
}

//test
<bean id="myBean" class="com.atguigu.spring5.collectiontype.myBean">
    
ApplicationContext context = new ClassPathXmlApplicationContext("example.xml");
User user = context.getBean("myBean",User.class);
System.out.println(user);

Bean的作用域

spring中默认创建的对象是单实例的（对象地址相等）。

<bean id="myBean" class="com.zero.spring5.collectiontype.myBean" scope="singleton"

多实例对象创建

<bean id="myBean" class="com.zero.spring5.collectiontype.myBean" scope="prototype"

scope:

singleton:单实例

prototype:多实例

Requst:一次请求

session:一次会话

Bean的生命周期

对象从创建到销毁的过程

（1）通过构造器创建bean实例（无参）

（2）为bean的属性设置值和对其他bean的引用（set）

（3）把bean实例传递给bean后置处理器方法

（3）调用bean的初始化方法（需要进行初始化配置）

在bean类中创建初始化的方法

（3）把bean实例传递给bean后置处理器的方法

（4）获取到bean

（5）当容器关闭的时候，调用bean的销毁方法（配置销毁方法）

在bean类中创建销毁的方法

使用（（ClassPathXmlApplicationContext）context).close()方法触发销毁方法，从而销毁对象

创建后置处理器

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

    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化方法之后执行")
        return bean;
    }
}
//xml中配置这个类
<bean id="myBean" class="com.atguigu.spring5.collectiontype.myBean">

xml自动装配

根据指定装配规则（属性名或者属性类型）进行自动装配

<bean id="myBean" class="com.atguigu.spring5.collectiontype.myBean" autowire="byName">
<bean id="bean" class="com.atguigu.spring5.collectiontype.myBean" autowire="byName"> //实现了根据名称将bean对象自动注入myBean对象中
//根据类型自动装配也是一样，不过当有多个相同类型的实例，就会报错

导入外部属性文件

<context:property-placeholder location="classpath:jdbc.properties"/>  //引入了jdbc.properties文件
<bean id="datasource" class= "com.alibaba.druid.pool.DruidDataSource">
	<property name="driverClassName" value = "${prop.driverClass}"></property>
    <property name="url" value = "${prop.url}"></property>
    <property name="username" value = "${prop.username}"></property>
    <property name="password" value = "${prop.password}"></property>
</bean>

基于注解方式

@service

@componet

@controller

@reposity

注入对象

@Autowired:根据类型自动装配

@Qualifier:根据属性名进行注入和autowired配合使用

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

注入普通类型：

@Value

组件扫描配置

//设置哪些内容不进行扫描
<context:component-scan base-package=“com.zero">
  	<context: exclude-filter type="annotation"
                             expression="com.zero.Controller"/>
                                               
</context:component-s>

//设置扫描哪些包
<context:component-scan base-package=“com.zero" use-default-filters="false">
  	<context: include-filter type="annotation"
                             expression="com.zero.Controller"/>
                                               
</context:component-s>

AOP 面向切面

不修改源代码进行功能增强

底层原理

1.AOP底层使用动态代理

有接口的情况（对接口实现类进行增强的情况）：使用jdk动态代理

创建一个接口实现类的代理对象，

使用jdk中Proxy类中的newProxyInstance创建代理方法

参数1：类加载器

参数2：增强方法所在的类，这个类实现的接口，支持多个接口

参数3：实现InvocationHandler,创建代理对象，写增强的方法

public class JDKProxy {
    
    public static void main(String[] args) {
        //需要增强方法实现的接口，可以是多个
        Class[] interfaces = {UserDao.class};
        UserDao o = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader()/*类加载器*/, interfaces/*增强方法实现的接口*/, new UserDaoProxy(new UserDaoImpl()) /*代理对象类*/);
        System.out.println(o.add(1, 2));
    }
}
class UserDaoProxy implements InvocationHandler{

    private  Object obj;
    //把创建的是谁的代理对象，把谁传过来（实现类）
    public UserDaoProxy(Object obj) {
        this.obj = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //方法之前
        System.out.println("方法之前执行：  " + method.getName() +  "   参数：" + Arrays.toString(args));
        //原来的逻辑
        Object invoke = method.invoke(obj, args);

        //方法之后
        System.out.println("方法执行之后执行。。。。。。");
        return invoke;
    }
}

没有接口的情况：使用CGLIB动态代理

创建当前类子类的代理对象

AOP术语

连接点

类里面的哪些方法可以被增强，这些方法就叫做连接点

切入点

实际真正被增强的方法叫切入点

通知（增强）

实际被增强的逻辑部分叫通知

通知有多种类型

前置通知

后置通知

环绕通知

异常通知

最终通知

切面

是一个动作，把通知应用到切入点的过程叫切面

AOP操作

基于AspectJ实现AOP操作

切入点表达式

表明对哪个类中的哪个方法进行增强

execution([权限修饰符][返回类型][类全路径][方法名称]（[方法参数列表]）)

execution(*com.zero.service.UserDao.add(1,2))

基于注解方式实现

1.创建一个类，在类里面定义方法，实现其增强

2.创建增强类（编写增强逻辑）

在增强类上面加上@Aspect注解生成代理对象

3.配置文件中开启生成代理对象

4.配置不同类型的通知

在增强类作为通知的方法上面添加通知类型注解并写切入点表达式

@Component
public class User {
    public void add() {
        System.out.println("add ........");
    }
}

//增强类
@Component
@Aspect
public class UserProxy {
    //前置通知
    @Before(value = "execution(* com.example.spring5.service.aop.User.add(..))")
    public void before() {
        System.out.println("before.......");
    }
    //在方法执行后
    @After(value = "execution(* com.example.spring5.service.aop.User.add(..))")
    public void after() {
        System.out.println("after");
    }
    //在方法返回值返回之后
    @AfterReturning(value = "execution(* com.example.spring5.service.aop.User.add(..))")
    public void afterRtreuning() {
        System.out.println("afterReturning");
    }
    //异常
    @AfterThrowing(value = "execution(* com.example.spring5.service.aop.User.add(..))")//
    public void afterThrowing() {
        System.out.println("afterThrowing");
    }
    @Around(value = "execution(* com.example.spring5.service.aop.User.add(..))") //方法执行前和执行后
    public void arount(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("增强前...");
        proceedingJoinPoint.proceed();//执行增强的方法
        System.out.println("增强后...");
    }

}

公共切入点抽取

 //切入点抽取
    @Pointcut(value = "execution(* com.example.spring5.service.aop.User.add(..))")
    public void point() {
        
    }

    //前置通知
    @Before(value = "point()")
    public void before() {
        System.out.println("before.......");
    }

事务管理：

@Transitional事务参数

propagation：参数传播

REQUEIRED:如果有事务在运行当前方法就在这个事务内运行，否则，就启动一个新的事务，并在自己的事务内运行
REQUEIRED_NEW:当前方法必须启动新事务，并在它自己的事务内运行，如果有事务正在运行，应该将它挂起
SUPPORTS:如果有事务在运行，当前的方法就在这个事务内运行，否则它可以不运行在事务中
NOT_SUPPORTS:当前方法不应该运行在事务中，如果有运行的事务，将它挂起
MANDATORY：当前的方法必须运行在事务内部，如果没有正在运行的事务就抛出异常
NEVER：当前的方法不应该运行在事务中，如果有运行的事务，就抛出异常
NESTED：如果有事务在运行，当前的方法就应该在这个事务的嵌套事务内运行，否则就启动一个新的事务，并在它自己的事务内运行

ioslation:事务隔离级别

三个读的问题：

脏读：一个未提交的事务读取到了另一个未提交事务的数据
不可重复读：一个未提交事务读取到了另一个已提交事务的数据
幻读：一个未提交事务读到了一个已经提交事务添加的数据

四个隔离级别：

READ UNCOMMITED：读未提交
READ COMMITED：读已提交
REPEATABLEED：可重复读(mysql默认，解决脏读和不可重复读)
SERIALIZABLE：串行化

timeout：超时时间

事务需要在一定时间内提交，如果不提交就进行回滚

readonly：是否只读

默认为false，通过设置为true来限制我们只读

rollbackFor:回滚

设置查询哪些异常进行事务回滚

norollbackFor

设置出现哪些异常不进行事务回滚

新特性

默认的日志框架从log4j变为log4j2
支持@Nullable:可以用在方法，属性，参数上，方法返回值可以为空，属性值可以为空，参数值可以为空
支持函数式编程
支持junit5
webflux: 一个异步非阻塞的框架
- springmvc是命令式编程，springwebfux是异步响应式编程

Zero-c

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Spring5快速入门，一文贯穿

Spring5快速入门，一文贯穿轻量级开源j2ee应用开发程序特点：方便解耦支持aop方便程序测试方便整合框架降低api开发难度方便事务操作IOC 控制反转把创建对象过程交给spring进行管理，降低耦合度底层原理xml解析、工厂模式、反射过程：使用xml创建对象使用xml解析技术解析通过反射创建对象Class clazz = Class.forName(解析出来的class路径)；return (类名)clazz.newInstance();IOC容器底
复制链接

扫一扫