sping学习笔记-基础

1.Spring简介

  • Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和AOP（Aspect Oriented Programming：面向切面编程）为内核。
  • 提供了展现层 SpringMVC 和持久层 Spring JDBCTemplate 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架

2. Spring配置

2.1 Spring pom 核心配置

配置applicationContext.xml文件

<properties>
    <spring.version>5.0.5.RELEASE</spring.version>
</properties>
<dependencies>
<!--导入spring的context坐标，context依赖core、beans、expression-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>
</dependencies>

2.2 spring配置文件(appclicationContext.xml)

2.2.1 Bean标签

  • scope:指对象的作用范围，取值如下：

    取值范围 说明
    singleton 默认值，只能通过IOC容器创建单个对象，在初始化IOC容器时创建
    protype 可创建多个对象，在getBean()时创建
    request WEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 request 域中
    session WEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 session 域中
    global session WEB 项目中，应用在 Portlet 环境，如果没有 Portlet 环境那么globalSession 相当于session

  • Bean 生命周期及说明

    1. 当scope的取值为singleton时
      Bean的实例化个数：1个
      Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例
      Bean的生命周期：
      + 对象创建：当应用加载，创建容器时，对象就被创建了
      + 对象运行：只要容器在，对象一直活着
      + 对象销毁：当应用卸载，销毁容器时，对象就被销毁了

    2. 当scope的取值为prototype时
      Bean的实例化个数：多个
      Bean的实例化时机：当调用getBean()方法时实例化Bean
      + 对象创建：当使用对象时，创建新的对象实例
      + 对象运行：只要对象在使用中，就一直活着
      + 对象销毁：当对象长时间不用时，被 Java 的垃圾回收器回收了

  • init-method：指定类中的初始化方法名称

  • destroy-method：指定类中销毁方法名称

2.2.2.1 注入方式

  1. set方法注入

    需要重写Getter和Setter

    • property属性

      <bean id="对象名称" class="全类名">
	<property name="需要注入的属性名称" ref="引用类型的对象名"/>
</bean>

    • bean 标签引入命名空间p xmlns:p="http://www.springframework.org/schema/p"

      <bean id="对象名称" class="全类名" p:属性名称-ref="引用类型的对象名"/>

  2. 构造方法注入

    • constructor-arg标签
      <bean id="对象名称" class="全类名">
	<constructor-arg name="参数名" ref="引用类型的对象名"/>
</bean>

  3. 其他数据类型的注入

    • 引用数据类型（ref=" "）

    • 普通数据类型(String int double...)

      <bean id="user1" class="cn.edu.cup.bean.User">
	<property name="name" value="张三"/>
	<property name="age" value="20"/>
</bean>
<bean id="user2" class="cn.edu.cup.bean.User">
	<property name="name" value="李四"/>
	<property name="age" value="18"/>
</bean>

    • 集合数据类型(map list)

      <bean id="userDao" class="cn.edu.cup.dao.impl.UserDaoImpl" scope="prototype">
	<property name="list">
		<list>
			<ref bean="user1"/>
			<ref bean="user2"/>
		</list>
	</property>
	<property name="map">
		<map>
			<entry key="user_1" value-ref="user1"/>
			<entry key="user_2" value-ref="user2"/>
		</map>
	</property>
	<property name="pro">
		<props>
			<prop key="p1">aaa</prop>
			<prop key="p2">bbb</prop>
			<prop key="p3">ccc</prop>
		</props>
	</property>
</bean>

2.2.2 引入其他配置文件

  • 可以将部分配置拆解到其他配置文件中，而在Spring主配置文件通过import标签进行加载
    <import resource="applicationContext-xxx.xml"/>

2.2.3 配置重点

<bean>标签
    id属性:在容器中Bean实例的唯一标识，不允许重复
    class属性:要实例化的Bean的全限定名
    scope属性:Bean的作用范围，常用是Singleton(默认)和prototype
<property>标签：属性注入
    name属性：属性名称
    value属性：注入的普通属性值
    ref属性：注入的对象引用值
    <list>标签
    <map>标签
    <properties>标签
    <constructor-arg>标签
<import>标签:导入其他的Spring的分文件

2.3 Spring相关API

  1. ClassPathXmlApplicationContext
    它是从类的根路径下加载配置文件 推荐使用这种
  2. FileSystemXmlApplicationContext
    它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
  3. AnnotationConfigApplicationContext
    当使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。
  • 上述类的getBean()方法
    public Object getBean(String name) throws BeansException {
	assertBeanFactoryActive();
	return getBeanFactory().getBean(name);
}

public <T> T getBean(Class<T> requiredType) throws BeansException {
	assertBeanFactoryActive();
	return getBeanFactory().getBean(requiredType);
}
  • 使用建议:
    • IOC容器存在多个对象/id时，使用getBean("id"),仍需要强转
    • IOC容器存在单个对象/id时，使用getBean(ClassName.class),不需要强转

3. Spring配置数据源

常见数据库连接池 DBCP、C3P0、BoneCP、Druid等

  • spring 加载properties文件并创建数据源
<!--加载类路径下jdbc.properties配置文件-->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!--创建数据源-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="${jdbc.driver}"/>
    <property name="jdbcUrl" value="${jdbc.url}"/>
    <property name="user" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
</bean>

4. spring注解开发

4.1 spring原始注解

注解 说明
@Component 使用在类上用于实例化Bean
@Controller 使用在web层类上用于实例化Bean
@Service 使用在service层类上用于实例化Bean
@Repository 使用在dao层类上用于实例化Bean
@Autowired 使用在字段上用于根据类型依赖注入
@Qualifier 结合@Autowired一起使用用于根据名称进行依赖注入
@Resource 相当于@Autowired+@Qualifier，按照名称进行注入
@Value 注入普通属性
@Scope 标注Bean的作用范围
@PostConstruct 使用在方法上标注该方法是Bean的初始化方法
@PreDestroy 使用在方法上标注该方法是Bean的销毁方法
  • 需先配置扫描组件功能
    <!--注解的组件扫描-->
<context:component-scan base-package="基路径"/>

4.2 spring新注解

可实现配置类进行配置

  • 新注解及说明
注解 说明
@Configuration 用于指定当前类是一个 Spring 配置类，当创建容器时会从该类上加载注解
@ComponentScan 用于指定 Spring 在初始化容器时要扫描的包。作用和在 Spring 的 xml 配置文件中的<context:component-scan base-package="需要扫描的类路径"/>一样
@Import 用于导入其他配置类
@Bean 使用在方法上，标注将该方法的返回值注入到 Spring 容器中
@PropertySource 用于加载.properties 文件中的配置
  • 加载配置类、IOC容器的方式
package cn.edu.cup.demo;

import cn.edu.cup.config.SpringConfig;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

public class AnnotationTest {
    public static void main(String[] args) throws SQLException {
        ApplicationContext ac=new AnnotationConfigApplicationContext(SpringConfig.class);
        DataSource dataSource = ac.getBean(DataSource.class);
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }
}

5. Spring整合Junit

  1. 导入Spring集成Junit的坐标

    <!--此处需要注意的是，spring5 及以上版本要求 junit 的版本必须是 4.12 及以上-->
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-test</artifactId>
	<version>5.3.14</version>
</dependency>

  2. 使用@Runwith注解替换原来的运行期
    @RunWith(SpringJUnit4ClassRunner.class)

  3. 使用@ContextConfiguration指定配置文件或配置类

     import org.springframework.test.context.ContextConfiguration;

 @ContextConfiguration(classes = {SpringCofiguration.class})

  4. 使用@Autowired注入需要测试的对象

  5. 创建测试方法进行测试

6. Spring AOP

6.1 Spring的AOP简介

  • AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理
    实现程序功能的统一维护的一种技术。

  • AOP 是 OOP 的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍
    生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序
    的可重用性，同时提高了开发的效率。

  • AOP 的底层是通过 Spring 提供的的动态代理技术实现的。在运行期间，Spring通过动态代理技术动态
    的生成代理对象，代理对象方法执行时进行增强功能的介入，在去调用目标对象的方法，从而完成功能的增强。

  • 常用的动态代理技术

    • JDK 代理 : 基于接口的动态代理技术
    • cglib 代理：基于父类的动态代理技术

  • 常用术语：

    • Target（目标对象）：代理的目标对象
    • Proxy （代理）：一个类被 AOP 织入增强后，就产生一个结果代理类
    • Joinpoint（连接点）：所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法，因为spring只支持方法类型的连接点
    • Pointcut（切入点）：所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义
    • Advice（通知/ 增强）：所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知
    • Aspect（切面）：是切入点和通知（引介）的结合
    • Weaving（织入）：是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入

  • aop的重点概念：

    • Pointcut（切入点）：被增强的方法
    • Advice（通知/ 增强）：封装增强业务逻辑的方法
    • Aspect（切面）：切点+通知
    • Weaving（织入）：将切点与通知结合的过程

  • 开发明确事项：

    • 谁是切点（切点表达式配置）
    • 谁是通知（切面类中的增强方法）
    • 将切点和通知进行织入配置

6.2 基于xml的AOP开发

  1. aop坐标

    <!--导入spring的context坐标，context依赖aop-->
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context</artifactId>
	<version>5.0.5.RELEASE</version>
</dependency>
<!-- aspectj的织入 -->
<dependency>
	<groupId>org.aspectj</groupId>
	<artifactId>aspectjweaver</artifactId>
	<version>1.8.13</version>
</dependency>

  2. 步骤

    • 导入AOP坐标
    • 创建目标接口和实现类（内部有切点）
    • 创建切面（内部有增强/通知方法）
    • 将目标类和切面类的对象创建权交给 spring
    • 在 applicationContext.xml 中配置织入关系
    • 测试代码

  3. applicationContext.xml 中配置织入关系

    <bean id="target" class="cn.edu.cup.aop.impl.Target"></bean>
<!--配置切面类-->
<bean id="myAspect" class="cn.edu.cup.aop.MyAspect"></bean>
<!--织入spring-->
<aop:config>
	<aop:aspect ref="myAspect">
		<!--前置增强-->
		<aop:before method="before" pointcut="execution(public void
		cn.edu.cup.aop.impl.Target.method())"/>
		<!--后置增强-->
		<aop:after-returning method="afterRutrun" pointcut="execution(
		void cn.edu.cup.aop.impl.Target.method())"/>
		<!--环绕增强-->
		<aop:around method="around" pointcut="execution(
		void cn.edu.cup.aop.impl.Target.method())"/>
		<!--异常增强-->
		<aop:after-throwing method="afterThrowing" pointcut="execution(
		void cn.edu.cup.aop.impl.Target.method())"/>
		<aop:after method="after" pointcut="execution(
		void cn.edu.cup.aop.impl.Target.method())"/>
	</aop:aspect>
</aop:config>

  4. 切点表达式的写法
    execution([修饰符] 返回值类型 包名.类名.方法名(参数))

    • 访问修饰符可以省略
    • 返回值类型、包名、类名、方法名可以使用星号* 代表任意
    • 包名与类名之间一个点 . 代表当前包下的类，两个点 .. 表示当前包及其子包下的类
    • 参数列表可以使用两个点 .. 表示任意个数，任意类型的参数列表

  5. 通知类型
    <aop:通知类型 method=“切面类中方法名” pointcut=“切点表达式"></aop:通知类型>

    名称 标签 说明
    前置通知 aop:before 用于配置前置通知。指定增强的方法在切入点方法之前执行
    后置通知 aop:after-returning 用于配置后置通知。指定增强的方法在切入点方法之后执行
    环绕通知 aop:around 用于配置环绕通知。指定增强的方法在切入点方法之前和之后都执行
    异常抛出通知 aop:throwing 用于配置异常抛出通知。指定增强的方法在出现异常时执行
    最终通知 aop:after 用于配置最终通知。无论增强方式执行是否有异常都会执行

  6. 切点表达式的抽取

    • 当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用 pointcut-ref 属性代替 pointcut 属性来引用抽取后的切点表达式。
      <aop:config>
	<aop:aspect ref="myAspect">
		<aop:pointcut id="myPointCut" expression="execution(void
		cn.edu.cup.aop.impl.Target.method())"/>
		<!--前置增强-->
		<aop:before method="before" pointcut-ref="myPointCut"/>
	</aop:aspect>
</aop:config>

  7. 小结

    • aop织入的配置

      <aop:config>
	<aop:aspect ref="切面类">
	<aop:before method="通知方法名称" pointcut="切点表达式"></aop:before>
	</aop:aspect>
</aop:config>

    • 通知的类型：前置通知、后置通知、环绕通知、异常抛出通知、最终通知

    • 切点表达式的写法：
      execution([修饰符] 返回值类型 包名.类名.方法名(参数))

6.3 基于注解的AOP开发

  1. 开启组件扫描和AOP自动代理
    <contex:component-scan base-package="cn.edu.cup.anno"/>
<!--aop的自动代理-->
<aop:aspectj-autoproxy/>
  2. 注解配置AOP详解

    • 切面类的配置
      @Component("myAspect") //要先开启AOP自动代理，如上配置
      @Aspect

    • 注解通知类型
      通知配置语法：@通知注解("切点表达式")

      名称 注解 说明
      前置通知 @Before 用于配置前置通知。指定增强的方法在切入点方法之前执行
      后置通知 @AfterReturning 用于配置后置通知。指定增强的方法在切入点方法之后执行
      环绕通知 @Around 用于配置环绕通知。指定增强的方法在切入点方法之前和之后都执行
      异常抛出通知 @AfterThrowing 用于配置异常抛出通知。指定增强的方法在出现异常时执行
      最终通知 @After 用于配置最终通知。无论增强方式执行是否有异常都会执行

    • 抽取切点表达式

      1. 标注切面类中方法上：@Pointcut("切点表达式")
      2. 其他通知引入该注解标注的方法即可
      //抽取切点
@Pointcut("execution(void cn.edu.cup.anno.impl.Target.method())")
public void goal(){};

Spring网课学习

posted @   4hm2  阅读(52)  评论(0)  编辑  收藏  举报
相关博文：
·  日志框架学习-log4j
·  MySQL笔记-约束
·  Spring Framework学习总结
·  spring全家桶
·  Spring知识点详解
阅读排行：
· 分享一个免费、快速、无限量使用的满血 DeepSeek R1 模型，支持深度思考和联网搜索！
· 25岁的心里话
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· 闲置电脑爆改个人服务器（超详细） #公网映射 #Vmware虚拟网络编辑器
· ollama系列01：轻松3步本地部署deepseek，普通电脑可用
点击右上角即可分享
微信分享提示