乐趣区

关于java:Spring初见

jiezi

一句话概括：

Spring 是一个轻量级的管制反转 (IoC) 和面向切面 (AOP) 的容器（框架）。

组成

  • 外围容器：外围容器提供 Spring 框架的基本功能。外围容器的次要组件是 BeanFactory，它是工厂模式的实现。

    BeanFactory 应用 管制反转（IOC）模式将应用程序的配置和依赖性标准与理论的利用程序代码离开。

  • Spring 上下文：简略了解就是 spring 的以后运行的环境，也能够了解是 spring 能够利用的资源。

  • Spring AOP：面向切面的编程性能，提供了事务管理服务。

    通过应用 Spring AOP，不必依赖组件，就能够将申明性事务管理集成到应用程序中。

  • Spring DAO：Spring DAO 的面向 JDBC 的异样听从通用的 DAO 异样层次结构。

  • Spring ORM：对象关系映射（Object Relational Mapping)。

    用于实现面向对象编程语言里不同类型零碎的数据之间的转换

  • Spring Web 模块：Web 上下文模块建设在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。
  • Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 包容了大量视图技术，其中包含 JSP、Velocity、Tiles、iText 和 POI。

Spring Boot 与 Spring Cloud

  • Spring Boot 是 Spring 的一套疾速配置脚手架，能够基于 Spring Boot 疾速开发单个微服务。
  • Spring Cloud 是基于 Spring Boot 实现的。
  • Spring Boot 专一于疾速、不便集成的单个微服务个体，Spring Cloud 关注全局的服务治理框架。
  • Spring Boot 应用了 束缚优于配置 的理念，很多集成计划曾经帮你抉择好了，能不配置就不配置 , Spring Cloud 很大的一部分是基于 Spring Boot 来实现，Spring Boot 能够来到 Spring Cloud 独立应用开发我的项目，然而 Spring Cloud 离不开 Spring Boot，属于依赖的关系。
  • SpringBoot 在 SpringClound 中起到了承前启后的作用。

IOC

管制反转 IoC(Inversion of Control)，是一种设计思维，DI 是实现 IOC 的一种办法。

  • 管制 : 谁来管制对象的创立 , 传统应用程序的对象是由程序自身管制创立的 , 应用 Spring 后 , 对象是由 Spring 来创立的
  • 反转 : 程序自身不创建对象 , 而变成被动的接管对象 .

依赖注入（Dependency Injection,DI）: 就是利用 set 办法来进行注入的。

IOC 是一种编程思维，由被动的编程变成被动的接管

一句话 : 对象由 Spring 来创立 , 治理 , 拆卸 !

以前设计一段代码：

// 先写一个 UserDao 接口
public interface UserDao {public void getUser();
}

// 再去写 Dao 的实现类
public class UserDaoImpl implements UserDao {
   @Override
   public void getUser() {System.out.println("获取用户数据");
  }
}


// 而后去写 UserService 的接口
public interface UserService {public void getUser();
}

// 最初写 Service 的实现类
public class UserServiceImpl implements UserService {private UserDao userDao = new UserDaoImpl();

   @Override
   public void getUser() {userDao.getUser();
  }
}

实现类 +++++++ 的时候

都须要批改大量代码，这种设计的耦合性太高了，牵一发而动全身。

咱们能够在须要用到他的中央 , 不去实现它 , 而是留出一个接口 , 利用 set , 咱们去代码里批改下。

public class UserServiceImpl implements UserService {
   private UserDao userDao;
// 利用 set 实现
   public void setUserDao(UserDao userDao) {this.userDao = userDao;}

   @Override
   public void getUser() {userDao.getUser();
  }
}

以前所有货色都是由程序去进行管制创立，而当初是由咱们自行管制创建对象。

程序不必去管怎么创立，怎么实现了，它只负责提供一个接口。

DI

  • 依赖注入（Dependency Injection,DI）。
  • 依赖 : 指 Bean 对象的创立依赖于容器，Bean 对象的依赖资源。
  • 注入 : 指 Bean 对象所依赖的资源，由容器来设置和拆卸。

1、常量注入

<bean id="student" class="com.zwt.pojo.Student">
     <property name="name" value="小明"/>
</bean>
    
   
    
@Test
 public void test01(){ApplicationContext context = new               ClassPathXmlApplicationContext("applicationContext.xml");
 
     Student student = (Student) context.getBean("student");
 
     System.out.println(student.getName());
 
 }

2、Bean 注入

留神点：这里的值是一个援用，ref。

 <bean id="addr" class="com.zwt.pojo.Address">
     <property name="address" value="重庆"/>
 </bean>
 
 <bean id="student" class="com.zwt.pojo.Student">
     <property name="name" value="小明"/>
     <property name="address" ref="addr"/>
 </bean>

3、Properties 注入

<property name="info">
     <props>
         <prop key="学号">20190604</prop>
         <prop key="性别"> 男 </prop>
         <prop key="姓名"> 小明 </prop>
     </props>
 </property>

…………

p 命名和 c 命名注入

1、P 命名空间注入 : 须要在头文件中退出束缚文件

导入束缚 : xmlns:p="http://www.springframework.org/schema/p"
 
 <!--P(属性: properties)命名空间 , 属性仍然要设置 set 办法 -->
 <bean id="user" class="com.zwt.pojo.User" p:name="zwt" p:age="18"/>

2、c 命名空间注入 : 须要在头文件中退出束缚文件（要写 写有参结构）

导入束缚 : xmlns:c="http://www.springframework.org/schema/c"
 <!--C(结构: Constructor)命名空间 , 属性仍然要设置 set 办法 -->
 <bean id="user" class="com.kuang.pojo.User" c:name="狂神" c:age="18"/>

Bean

在 Spring 中，那些组成应用程序的主体及由 Spring IoC 容器所治理的对象，被称之为 bean。

简略地讲，bean 就是由 IoC 容器初始化、拆卸及治理的对象。

几种作用域：

Singleton

Spring IoC 容器中只会存在一个共享的 bean 实例，并且所有对 bean 的申请，只有 id 与该 bean 定义相匹配，则只会返回 bean 的同一实例。

Singleton 是 单例类型，就是在创立起容器时就同时主动创立了一个 bean 的对象，不论你是否应用，他都存在了，每次获取到的对象都是同一个对象。

留神，Singleton 作用域是 Spring 中的缺省作用域。

 <bean id="ServiceImpl" class="cn.csdn.service.ServiceImpl" scope="singleton">

Prototype

示意一个 bean 定义对应多个对象实例。

Prototype 作用域的 bean 会导致在每次对该 bean 申请时都会创立一个新的 bean 实例。

Prototype 是 原型类型，它在咱们创立容器的时候并没有实例化，而是当咱们获取 bean 的时候才会去创立一个对象，而且咱们每次获取到的对象都不是同一个对象。

 <bean id="account" class="com.foo.DefaultAccount" scope="prototype"/>    
 
 或者 
 
 <bean id="account" class="com.foo.DefaultAccount" singleton="false"/>

Request

示意在一次 HTTP 申请中，一个 bean 定义对应一个实例。

即每个 HTTP 申请都会有各自的 bean 实例，它们根据某个 bean 定义创立而成。

该作用域仅在基于 web 的 Spring ApplicationContext 情景下无效。

 <bean id="loginAction" class=cn.csdn.LoginAction"scope="request"/>

针对每次 HTTP 申请，Spring 容器会依据 loginAction bean 的定义创立一个全新的 LoginAction bean 实例，

且该 loginAction bean 实例仅在以后 HTTP request 内无效，

当解决申请完结，request 作用域的 bean 实例将被销毁。

Session

示意在一个 HTTP Session 中，一个 bean 定义对应一个实例。

该作用域仅在基于 web 的 Spring ApplicationContext 情景下无效。

 <bean id="userPreferences" class="com.foo.UserPreferences" scope="session"/>

针对某个 HTTP Session，Spring 容器会依据 userPreferences bean 定义创立一个全新的 userPreferences bean 实例，

且该 userPreferences bean 仅在以后 HTTP Session 内无效。

当 HTTP Session 最终被废除的时候，在该 HTTP Session 作用域内的 bean 也会被废除掉。

主动拆卸

  • 主动拆卸是应用 spring 满足 bean 依赖的一种办法
  • spring 会在利用上下文中为某个 bean 寻找其依赖的 bean。

Spring 中 bean 有三种拆卸机制，别离是：

  1. 在 xml 中显式配置；
  2. 在 java 中显式配置；
  3. 隐式的 bean 发现机制和主动拆卸。

自动化的拆卸 bean：

  1. 组件扫描(component scanning)：spring 会主动发现利用上下文中所创立的 bean。
  2. 主动拆卸(autowiring)：spring 主动满足 bean 之间的依赖，也就是咱们说的 IoC/DI。

组件扫描和主动拆卸组合施展微小威力，使得显示的配置升高到起码。

举荐应用注解进行主动拆卸

1、在 spring 配置文件中引入 context 文件头

xmlns:context="http://www.springframework.org/schema/context"

http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd

2、开启属性注解反对！

<context:annotation-config/>

@Autowired

  • @Autowired 是按类型主动转配的，不反对 id 匹配。
  • 须要导入 spring-aop 的包！

测试：

public class User {
   @Autowired
   private Cat cat;
   
   private String str;

   public Cat getCat() {return cat;}
   
   public String getStr() {return str;}
}

2、此时配置文件内容

<context:annotation-config/>

<bean id="dog" class="com.zwt.pojo.Dog"/>

@Autowired(required=false) 阐明：false，对象能够为 null；true，对象必须存对象，不能为 null。

// 如果容许对象为 null，设置 required = false, 默认为 true@Autowired(required = false)private Cat cat;

@Qualifier

  • @Autowired 是依据类型主动拆卸的，加上 @Qualifier 则能够依据 byName 的形式主动拆卸
  • @Qualifier 不能独自应用。

1、配置文件批改内容，保障类型存在对象。且名字不为类的默认名字！

<bean id="dog1" class="com.zwt.pojo.Dog"/>
<bean id="dog2" class="com.zwt.pojo.Dog"/>
<bean id="cat1" class="com.zwt.pojo.Cat"/>
<bean id="cat2" class="com.zwt.pojo.Cat"/>

2、没有加 Qualifier 测试，间接报错

3、在属性上增加 Qualifier 注解

@Autowired
@Qualifier(value = "cat2")
private Cat cat;
@Autowired
@Qualifier(value = "dog2")
private Dog dog;

测试，胜利输入！

@Resource

  • @Resource 如有指定的 name 属性，先按该属性进行 byName 形式查找拆卸；
  • 其次再进行默认的 byName 形式进行拆卸；
  • 如果以上都不胜利，则按 byType 的形式主动拆卸。
  • 都不胜利，则报异样。

实体类：

public class User {
   // 如果容许对象为 null，设置 required = false, 默认为 true
   @Resource(name = "cat2")
   private Cat cat;
   @Resource
   private Dog dog;
   private String str;
}

beans.xml

<bean id="dog" class="com.kuang.pojo.Dog"/>
<bean id="cat1" class="com.kuang.pojo.Cat"/>
<bean id="cat2" class="com.kuang.pojo.Cat"/>
<bean id="user" class="com.kuang.pojo.User"/>

测试：后果 OK

配置文件 2：beans.xml，删掉 cat2

<bean id="dog" class="com.kuang.pojo.Dog"/>
<bean id="cat1" class="com.kuang.pojo.Cat"/>

实体类上只保留注解

@Resource
private Cat cat;
@Resource
private Dog dog;

后果：OK

论断：先进行 byName 查找，失败；再进行 byType 查找，胜利。

小结

@Autowired 与 @Resource 异同：

1、@Autowired 与 @Resource 都能够用来拆卸 bean。都能够写在字段上，或写在 setter 办法上。

2、@Autowired 默认按类型拆卸（属于 spring 标准），默认状况下必须要求依赖对象必须存在，如果要容许 null 值，能够设置它的 required 属性为 false。

如：@Autowired(required=false)，如果咱们想应用名称拆卸能够联合 @Qualifier 注解进行应用

3、@Resource（属于 J2EE 复返），默认依照名称进行拆卸，名称能够通过 name 属性进行指定。

@Autowired 先 byType，@Resource 先 byName。

动态 and 动静代理

AOP 的底层机制就是动静代理

动态代理

所谓的代理模式，程序源自于生存

如同现实生活中的你租房子，你看不到房东，然而你仍旧通过代理 租到了房东的房子。

长处：

  • 能够使得咱们的实在角色更加纯正 . 不再去关注一些公共的事件 .
  • 公共的业务由代理来实现 . 实现了业务的分工 ,
  • 公共业务产生扩大时变得更加集中和不便 .

毛病 :

  • 类多了 , 多了代理类 , 工作质变大了 . 开发效率升高 .
// 形象角色：租房
public interface Rent {public void rent();
}


// 实在角色: 房东，房东要出租房子
public class Host implements Rent{public void rent() {System.out.println("房屋出租");
  }
}


// 代理角色：中介
public class Proxy implements Rent {

   private Host host;
   public Proxy() {}
   public Proxy(Host host) {this.host = host;}

   // 租房
   public void rent(){seeHouse();
       host.rent();
       fare();}
   // 看房
   public void seeHouse(){System.out.println("带房客看房");
  }
   // 收中介费
   public void fare(){System.out.println("收中介费");
  }
}


// 客户类，个别客户都会去找代理！public class Client {public static void main(String[] args) {
       // 房东要租房
       Host host = new Host();
       // 中介帮忙房东
       Proxy proxy = new Proxy(host);

       // 你去找中介！proxy.rent();}
}

动静代理

  • 动静代理分为两类 : 一类是基于接口动静代理 , 一类是基于类的动静代理
    • 基于接口的动静代理 —-JDK 动静代理
    • 基于类的动静代理 –cglib
    • 当初用的比拟多的是 JAVAssist 来生成动静代理

JDK 的动静代理须要理解两个类：

外围 : InvocationHandler 和 Proxy

Object invoke(Object proxy, 办法 method, Object[] args)；

proxy – 调用该办法的代理实例

method - 所述办法对应于调用代理实例上的接口办法的实例。

办法对象的申明类将是该办法申明的接口，它能够是代理类继承该办法的代理接口的超级接口。

args - 蕴含的办法调用传递代理实例的参数值的对象的阵列，或 null 如果接口办法没有参数。

原始类型的参数蕴含在适当的原始包装器类的实例中，例如 java.lang.Integer 或 java.lang.Boolean。

// 生成代理类
public Object getProxy(){return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                                 rent.getClass().getInterfaces(),this);
}

例子：

// 形象角色：租房
public interface Rent {public void rent();
}

// 实在角色: 房东，房东要出租房子
public class Host implements Rent{public void rent() {System.out.println("房屋出租");
  }
}


//ProxyInvocationHandler. java 即代理角色
public class ProxyInvocationHandler implements InvocationHandler {
   private Rent rent;

   public void setRent(Rent rent) {this.rent = rent;}

   // 生成代理类，重点是第二个参数，获取要代理的形象角色！之前都是一个角色，当初能够代理一类角色
   public Object getProxy(){return Proxy.newProxyInstance(this.getClass().getClassLoader(),
               rent.getClass().getInterfaces(),this);
  }

   // proxy : 代理类 method : 代理类的调用处理程序的办法对象.
   // 解决代理实例上的办法调用并返回后果
   @Override
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {seeHouse();
       // 外围：实质利用反射实现！Object result = method.invoke(rent, args);
       fare();
       return result;
  }

   // 看房
   public void seeHouse(){System.out.println("带房客看房");
  }
   // 收中介费
   public void fare(){System.out.println("收中介费");
  }

}


/ 租客
public class Client {public static void main(String[] args) {
       // 实在角色
       Host host = new Host();
       // 代理实例的调用处理程序
       ProxyInvocationHandler pih = new ProxyInvocationHandler();
       pih.setRent(host); // 将实在角色搁置进去！Rent proxy = (Rent)pih.getProxy(); // 动静生成对应的代理类！proxy.rent();}

}

外围：一个动静代理 , 个别代理某一类业务 , 一个动静代理能够代理多个类，代理的是接口！

长处：

  • 能够使得咱们的实在角色更加纯正 . 不再去关注一些公共的事件 .
  • 公共的业务由代理来实现 . 实现了业务的分工 ,
  • 公共业务产生扩大时变得更加集中和不便 .
  • 一个动静代理 , 个别代理某一类业务
  • 一个动静代理能够代理多个类，代理的是接口！

AOP

AOP（Aspect Oriented Programming）意为：面向切面编程。

通过预编译形式和运行期动静代理实现程序性能的对立保护的一种技术。

AOP 是 OOP 的连续，是软件开发中的一个热点，也是 Spring 框架中的一个重要内容，是函数式编程的一种衍生范型。

利用 AOP 能够对业务逻辑的各个局部进行隔离，从而使得业务逻辑各局部之间的耦合度升高，进步程序的可重用性，同时进步了开发的效率。

作用

提供申明式事务，容许用户自定义切面。

SpringAOP 中，通过 Advice 定义横切逻辑，Spring 中反对 5 种类型的 Advice:

  1. 前置加强 (org.springframework.aop.BeforeAdvice) 示意在指标办法执行前来施行加强
  2. 后置加强 (org.springframework.aop.AfterReturningAdvice)
    示意在指标办法执行起初施行加强
  3. 盘绕加强 (org.aopalliance.intercept.MethodInterceptor)
    示意在指标办法执行前后同时施行加强
  4. 异样抛出加强 (org.springframework.aop.ThrowsAdvice) 示意在指标办法抛出异样起初施行加强
  5. 引介加强 (org.springframework.aop.introductioninterceptor)
    示意在指标类中增加一些新的办法和属性

即 Aop 在 不扭转原有代码的状况下，去减少新的性能。

【重点】应用 AOP 织入，须要导入一个依赖包！

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
   <groupId>org.aspectj</groupId>
   <artifactId>aspectjweaver</artifactId>
   <version>1.9.4</version>
</dependency>

第一种形式（通过 Spring API 实现）

// 首先编写咱们的业务接口和实现类
public interface UserService {public void add();

   public void delete();}


public class UserServiceImpl implements UserService{

   @Override
   public void add() {System.out.println("减少用户");
  }

   @Override
   public void delete() {System.out.println("删除用户");
  }
    
}


// 而后去写咱们的加强类 , 咱们编写两个 , 一个前置加强 一个后置加强

public class Log implements MethodBeforeAdvice {

   //method : 要执行的指标对象的办法
   //objects : 被调用的办法的参数
   //Object : 指标对象
   @Override
   public void before(Method method, Object[] objects, Object o) throws Throwable {System.out.println( o.getClass().getName() + "的" + method.getName() + "办法被执行了");
  }
}

public class AfterLog implements AfterReturningAdvice {
   //returnValue 返回值
   //method 被调用的办法
   //args 被调用的办法的对象的参数
   //target 被调用的指标对象
   @Override
   public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {System.out.println("执行了" + target.getClass().getName()
       +"的"+method.getName()+"办法,"
       +"返回值："+returnValue);
  }
}



// 最初去 spring 的文件中注册 , 并实现 aop 切入实现 , 留神导入束缚 


<?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:aop="http://www.springframework.org/schema/aop"
      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">

   <!-- 注册 bean-->
   <bean id="userService" class="com.zwt.service.UserServiceImpl"/>
   <bean id="log" class="com.zwt.log.Log"/>
   <bean id="afterLog" class="com.zwt.log.AfterLog"/>

   <!--aop 的配置 -->
   <aop:config>
       <!-- 切入点 expression: 表达式匹配要执行的办法 -->
       <aop:pointcut id="pointcut" expression="execution(* com.zwt.service.UserServiceImpl.*(..))"/>
       <!-- 执行盘绕; advice-ref 执行办法 . pointcut-ref 切入点 -->
       <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
       <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
   </aop:config>

</beans>
测试

public class MyTest {
   @Test
   public void test(){ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
       UserService userService = (UserService) context.getBean("userService");
       userService.search();}
}

Spring 的 Aop 就是将公共的业务 (日志 , 平安等) 和畛域业务联合起来 ,

当执行畛域业务时 , 将会把公共业务加进来 . 实现公共业务的反复利用

畛域业务更纯正 , 专一畛域业务 , 其本质还是动静代理 .

第二种形式（自定义类来实现 Aop）

// 第一步 : 写咱们本人的一个切入类

public class DiyPointcut {public void before(){System.out.println("--------- 办法执行前 ---------");
  }
   public void after(){System.out.println("--------- 办法执行后 ---------");
  }
   
}

// 去 spring 中配置
<!-- 第二种形式自定义实现 -->
<!-- 注册 bean-->
<bean id="diy" class="com.zwt.config.DiyPointcut"/>

<!--aop 的配置 -->
<aop:config>
   <!-- 第二种形式：应用 AOP 的标签实现 -->
   <aop:aspect ref="diy">
       <aop:pointcut id="diyPonitcut" expression="execution(* com.zwt.service.UserServiceImpl.*(..))"/>
       <aop:before pointcut-ref="diyPonitcut" method="before"/>
       <aop:after pointcut-ref="diyPonitcut" method="after"/>
   </aop:aspect>
</aop:config>

  
    

public class MyTest {
   @Test
   public void test(){ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
       UserService userService = (UserService) context.getBean("userService");
       userService.add();}
}

第三种形式（应用注解实现）

// 第一步：编写一个注解实现的加强类

@Aspect
public class AnnotationPointcut {@Before("execution(* com.kuang.service.UserServiceImpl.*(..))")
   public void before(){System.out.println("--------- 办法执行前 ---------");
  }

   @After("execution(* com.kuang.service.UserServiceImpl.*(..))")
   public void after(){System.out.println("--------- 办法执行后 ---------");
  }

   @Around("execution(* com.kuang.service.UserServiceImpl.*(..))")
   public void around(ProceedingJoinPoint jp) throws Throwable {System.out.println("盘绕前");
       System.out.println("签名:"+jp.getSignature());
       // 执行指标办法 proceed
       Object proceed = jp.proceed();
       System.out.println("盘绕后");
       System.out.println(proceed);
  }
}

// 第二步：在 Spring 配置文件中，注册 bean，并减少反对注解的配置

<!-- 第三种形式: 注解实现 -->
<bean id="annotationPointcut" class="com.zwt.config.AnnotationPointcut"/>
<aop:aspectj-autoproxy/>

通过 aop 命名空间的 <aop:aspectj-autoproxy /> 申明

主动为 spring 容器中那些配置 @aspectJ 切面的 bean 创立代理，织入切面。

当然，spring 在外部仍旧采纳 AnnotationAwareAspectJAutoProxyCreator 进行主动代理的创立工作，

但具体实现的细节曾经被 <aop:aspectj-autoproxy /> 暗藏起来了

<aop:aspectj-autoproxy /> 有一个 proxy-target-class 属性，默认为 false，示意应用 jdk 动静代理织入加强，

当配为 <aop:aspectj-autoproxy poxy-target-class=”true”/> 时，示意应用 CGLib 动静代理技术织入加强。

不过即便 proxy-target-class 设置为 false，如果指标类没有申明接口，则 spring 将主动应用 CGLib 动静代理。

参考链接：

https://www.bilibili.com/vide…

退出移动版