JAVA进阶之Spring

最新推荐文章于 2021-04-02 22:37:03 发布

千与千珏

最新推荐文章于 2021-04-02 22:37:03 发布

阅读量167

点赞数

分类专栏： Java 框架文章标签： Spring

本文链接：https://blog.csdn.net/weixin_44205039/article/details/101291795

版权

Java 框架专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Spring

官网：https://spring.io

优秀的java开源框架。

作用：项目管理。管理组件(对象 DAO，Service，Controller)。

设计思路：践行工厂模式，打造一个工厂，通过工厂完成对项目的管理。

spring工厂搭建

1. 导入依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
    <version>4.3.6.RELEASE</version>
</dependency>

spring 核心jar，其中核心容器 jar：beans、context、context-support、core、expression

2. 配置文件

配置文件作用：描述哪些组件需要spring生产，管理**

文件位置：resources目录

文件名称：随意. 常用名 :applicationContext.xml beans.xml

applicationContext.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 作用：声明需要spring 生产的组件 -->
    <!-- UserDAOImpl组件  id="组件标识" class="组件类型" -->
    <bean id="userDAO" class="com.zhj.dao.UserDAOImpl"></bean>
    <!-- UserServiceImpl组件 -->
    <bean id="userService" class="com.zhj.service.UserServiceImpl"></bean>
    ....
</beans>

3. 启动工厂

// 启动工厂，注意：需要指定配置文件位置
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
// 从工厂中获取 标识为"userDAO"的组件
UserDAO userDAO = (UserDAO)context.getBean("userDAO")

强耦合

项目由一个个的组件组成，而组件之间都不是孤立的。会彼此依赖。
类之间的关系紧密程度，即耦合度。关系松散即弱耦合，关系密切即强耦合。
一旦强耦合：组件即陷入不稳健的状态，不稳健的组件将导致整个项目的形态极差。

项目中的具体体现：Controller 依赖 Service 、Service 依赖 DAO 、…

spring介入后，可以以全新的方式处理依赖关系，既保证依赖健全，又没有强耦合。

IOC (重点)

Inverse Of Controll`:控制反转

反转了依赖关系的满足方式，由之前的自己创建依赖对象，变为由工厂推送。(变主动为被动，即反转)

解决了具有依赖关系的组件之间的强耦合，使得项目形态更加稳健

DI

Dependency Injection：依赖注入

全新的依赖满足方式，体现在编码中就是全新的赋值方式 ==> 在工厂中为属性推送值

如：<property name="userDAO" ref="userDAO"></property>

IOC 和 DI

在spring中关于IOC和DI的描述是这样的:** IOC(DI)，即，是一码事

IOC 是思想：指导我们在满足依赖时，应该有反转的设计。

DI 是手段：实际操作时，就是在一次次的注入

DI的配置使用

方式

set注入：
- 借助set方法完成注入
构造注入
- 借助构造方法完成注入
自动注入
- spring自动识别属性，并注入

1. set注入

<bean id="setDI" class="x.xx.XXX">
    <!-- jdk 8种基本类型+String -->
    <property name="age" value="18"></property>
    <property name="name" value="zhj"></property>
    <property name="gender" value="true"></property>
    <!-- 引用类型  -->
    <property name="userDAO" ref="ud"></property>
    <!-- List或数组 -->
    <property name="list">
        <list>
            <value>18</value>
            <ref bean="ud"/>
        </list>
    </property>
    <!-- set -->
    <property name="xxx">
        <set>
            <value>xx</value>
        </set>
    </property>
    <!-- map -->
    <property name="map">
        <map>
            <entry key="name" value="zhj"></entry>
            <entry key="userDAO" value-ref="ud"></entry>
        </map>
    </property>
    <!-- properties -->
    <property name="prop">
        <props>
            <prop key="url">jdbc:oracle:xxxx</prop>
        </props>
    </property>
</bean>

2. 构造注入

<bean id="consDI" class="com.test.TestConstrutorDIComponent">
	<!-- index=构造参数索引    type:构造参数类型   value=构造参数值 -->
 	<constructor-arg index="0" type="java.lang.Integer" value="18"></constructor-arg>
 	<constructor-arg index="1" type="java.lang.String" value="zhj"></constructor-arg>
 	<constructor-arg index="2" type="java.lang.Boolean" value="true"></constructor-arg>
</bean>

混合使用

<bean id="consDI04" class="com.qianfeng.di.ConsComponent">
    <!-- 构造和set注入混用 -->
    <constructor-arg index="0" type="java.lang.Integer" value="4"></constructor-arg>
    <property name="name" value="yueqi"/>
    <property name="gender" value="false"/>
</bean>

3. 自动注入

<!-- 基于属性名自动注入=将和属性"同名"的bean 赋值给属性 -->
<bean id="xx" class="xxx" autowire="byName"></bean>
<!-- 基于属性类型自动注入=将和属性"同类型"的bean 赋值给属性 -->
<bean id="xx" class="xxx" autowire="bytype"></bean>

工厂Bean

FactoryBean:生产某一类对象

在工厂中有些bean，无法直接通过简单的<bean></bean>生产。**

比如：Connection，SqlSessionFactory

FactoryBean

// 1.实现FactoryBean
public class MySqlSessionFactoryBean implements FactoryBean<SqlSessionFactory>{
    public SqlSessionFactory getObject(){
        //完成SqlSessionFactory的生产，并返回生产的对象
    }
    ...
}

<!-- 通过该Id获取bean时，返回的不是工厂bean本身的对象，而是其生产的对象 -->
<bean id="sqlSessionFactory" class="com.zhj.factory.MySqlSessionFactoroyBean"></bean>

静态工厂方法

// 2.静态工厂方法
public class MyFactoryBean {
    public static User createUser(){
        return new User();
    }
}

<bean id="user" factory-method="createUser" class="com.zhj.factory.MyFactoryBean" scope="xx"></bean>

工厂方法

// 3.工厂方法
public class MyFactoryBean {
    public User createUser(){
        return new User();
    }
}

<bean id="userFactory" class="com.zhj.factory.bean.MyFactoryBean"></bean>
<bean id="user" factory-bean="userFactory" factory-method="createUser" scope="xx"></bean>

测试

//获取bean，此时获取的并不是FactoryBean,而是其生产的对象。
SqlSessionFactory sqlSessionFactory = (sqlSessionFactory)context.getBean("sqlSessionFactory");
//获取bean，此时获取的并不是FactoryBean,而是其生产的对象。
User user = (User)context.getBean("user");

AOP

Spring-AOP 是对 AOP框架之一。其他比如还有AspectJ

Aspect-Oriented-Programming(面向切面编程)，一种编程思想。

切面：Aspect，由切入点和额外功能（增强）组成。

作用：提供了新的编程角度，不再只是考虑类、对象，而可以考虑切面。切面和目标形成 代理，解决项目业务中额外功 能冗余的问题。

业务中的问题

业务层中存在问题：两类逻辑=核心业务+额外功能，其中额外功能存在大量的代码冗余：使得项目维护存在极大隐患。

class UserServiceImpl implements UserService{
	private UserDAO ud;
    public void updateUser(User user){
        System.out.println("事务管理功能");//额外功能 冗余
        ud.update(user); //核心功能
    }
    public void inserUser(User user){
        System.out.println("事务管理功能");//额外功能 冗余
        ud.insertUser(user);//核心功能
    }
    public User queryUser(Integer id){
        System.out.println("事务管理功能");//额外功能 冗余
        ud.queryUser(id);//核心功能
    }
}

静态代理

代目标类打理了额外功能

目标类：UserServiceImpl ,即，被代理的类

代理类原则：要和原始的业务(target)实现同样的接口,保持功能一致。
代理类组成：额外功能(Advice) +目标(Target)

解决了目标类的冗余问题，但自身却依然有冗余！！

class UserServiceProxy implements UserService{//代理类
    UserService us=new UserServiceImpl();
    public void updateUser(User user){
        System.out.println("事务管理功能"); //代理类负责额外功能
        us.updateUser(user); // 目标自己负责核心功能
    }
    public void inserUser(User user){ 
        System.out.println("事务管理功能");//代理类负责额外功能
        us.insertUser(user);// 目标自己负责核心功能
    }
    public User queryUser(Integer id){ 
        System.out.println("事务管理功能");//代理类负责额外功能
        us.queryUser(user);// 目标自己负责核心功能
    }
}

// 创建代理对象，完成业务
UserService userService = new UserServiceProxy();
userService.insertUser(user);

动态代理

通过动态字节码技术，在运行时动态生成代理( 反射 )。

则既不用维护代理类，有可以有代码打理额外功能。

动态代理的实现方案：

jdk代理（ jdk在反射包中提供的一套api ）通过和目标实现相同的接口保证功能一致
cglib代理 ( 第三方cglib库中的一套api ) 通过继承目标保证功能一致

Spring的AOP章节，底层采纳了如上两种代理实现，并对动态代理提供了，简单的，可操作性强的决绝方案。

当项目中需要使用代理解决问题时，可以采用AOP章节的内容加以解决。

AOP 编码流程

 <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
    <version>4.3.6.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>4.3.6.RELEASE</version>
</dependency>

1 准备 Target（切入点）

public class UserServiceImpl implements UserService{
    private UserDAO userDAO;
    // set/get...
    @Override
    public void updateUser(User user) {
        System.out.println("update in service===============");
        userDAO.updateUser(user);
    }
    @Override
    public void insertUser(User user) {
        System.out.println("insert in service===============");
        userDAO.insertUser(user);
    }
}

2 准备 Advice（额外功能）

public class MyBeforeAdvice implements MethodBeforeAdvice{

/**
 * @param method 当前执行的方法
 * @param args   当前执行的方法中的参数
 * @param target 目标对象
 * @throws Throwable
 */
@Override
public void before(Method method, Object[] args, Object target) throws Throwable {
    System.out.println("before~~~");
}
}

3 编织 Weave（！！修改一点applicationContext.xml上面的配置！！）（xmlns:aop–aop自定义）

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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
                            http://www.springframework.org/schema/aop
                            http://www.springframework.org/schema/aop/spring-aop.xsd
    ">
<!-- 声明 Target + Advice -->
<!-- 声明 Target -->
<bean id="userService" class="com.zhj.service.UserServiceImpl">
    <!-- 为userDAO属性赋值，值为id=“userDAO”的组件 -->
    <property name="userDAO" ref="userDAO"/>
</bean>
<!-- Advice -->
<bean id="myBefore" class="com.zhj.advice.MyBeforeAdvice"/>

<!-- 编织 配置 -->
<aop:config>
    <!-- ref="引入MyAdvice" -->
    <aop:aspect ref="myAdvice">
        <!-- 切入点=pointcut
 			execution()表达式：描述切入位置
            组成：修饰符   返回值      包      类  方法名  参数表
                 public Integer com.xx.xxx.AA.xxxXXX(int,String)
            * com.service.UserServiceImpl.*(..)：com.service包下UserServiceImpl类中，返回值修饰符任意，方法名任意， 参数表任意
            * com.service.UserServiceImpl.queryUser(..)：同上，只是方法名不是任意，而是 ”queryUser“
		-->
        <aop:pointcut id="pc" expression="execution(* com.service.UserServiceImpl.queryUser(..))"/>
        <aop:advisor advice-ref="myBefore" pointcut-ref="pc"/>
    </aop:aspect>
</aop:config>

测试

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = (UserService)context.getBean("userService");
userService.insertUser(new User(...));

多种Advice

1 前置额外功能

public class MyBeforeAdvice implements MethodBeforeAdvice{

    /**
     * @param method 当前执行的方法
     * @param args   当前执行的方法中的参数
     * @param target 目标对象
     * @throws Throwable
     */
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("before~~~");
    }
}

2 后置额外功能

public class MyAfterAdvice implements AfterReturningAdvice{

/**
 *
 * @param returnValue  目标业务方法返回值
 * @param method       当前执行的业务方法对象
 * @param args         方法的参数
 * @param target       目标对象
 * @throws Throwable
 */
@Override
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
    System.out.println("after~~~");
}

}

3 环绕额外功能

public class MyMethodInterceptor implements MethodInterceptor{

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        System.out.println("begin~~");
        Object ret = invocation.proceed();//执行目标业务方法
        System.out.println("end~~");
        return ret;//返回目标业务方法返回值
    }
}

4 异常额外功能

public class MyThrows implements ThrowsAdvice{
    //目标业务方法中抛出异常时，执行此方法。ex=抛出的异常对象
    public void afterThrowing(Exception ex){
        System.out.println(ex.getMessage()+"~~~");
    }
}

切入点表达式

1 execution

1> * com.service.UserServiceImpl.queryUser(..)
    修饰符：任意
    返回值：任意
    包:com.service
    类：UserServiceImpl
    方法：queryUser
    参数表：任意
2> * com.service.UserServiceImpl.*(..)
    修饰符：任意
    返回值：任意
    包:com.service
    类：UserServiceImpl
    方法：所有，任意
    参数表：任意
3> * com..UserServiceImpl.*(..)
    修饰符：任意
    返回值：任意
    包:com包，及其子包
    类：UserServiceImpl
    方法：所有，任意
    参数表：任意
4> * com.service.*.*(..)
    修饰符：任意
    返回值：任意
    包:com.service
    类：所有，任意
    方法：所有，任意
    参数表：任意
5> * *(..)    不建议
    修饰符：任意
    返回值：任意
    包:任意
    类：所有，任意
    方法：所有，任意
    参数表：任意
6> * com.service.UserServiceImpl.query*(..)  【技巧:批量切入】
    修饰符：任意
    返回值：任意
    包:com.service
    类：UserServiceImpl
    方法：所有，任意
    参数表：任意
  *注意：尽量精确，避免不必要的切入

2 within
描述包和类，类中所有方法都切入

within(com.service.UserServiceImpl) 类中的所有方法
within(com..UserServiceImpl) com包和com子包下的类中的所有方法

<aop:pointcut id="pc" expression="within(com..UserServiceImpl)"/>

3 args
描述参数表，符合的方法都切入

args(int,String,com.entity.User) 参数表如此的方法

<aop:pointcut id="pc" expression="args(int,String,com.entity.User)"/>

联用
不同种类的表达式之间，可以使用逻辑运算：

and or not

<aop:pointcut id="pc" expression="execution(* com.zhj.service.UserServiceImpl.*(..)) and args(com.User)"/>
<aop:pointcut id="pc" expression="within(com.service.UserServiceImpl) or args(com.User)"/>
<aop:pointcut id="pc" expression="within(com.service.UserServiceImpl) and not args(com.User)"/>

千与千珏

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA进阶之Spring

Spring官网：https://spring.io优秀的java开源框架。作用：项目管理。管理组件(对象 DAO，Service，Controller)。设计思路：践行工厂模式，打造一个工厂，通过工厂完成对项目的管理。spring工厂搭建1. 导入依赖<dependency> <groupId>org.springframework</gr...
复制链接

扫一扫