Spring学习笔记

最新推荐文章于 2025-10-29 14:15:27 发布

原创最新推荐文章于 2025-10-29 14:15:27 发布 · 267 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#spring #框架 #java

Spring学习专栏收录该内容

10 篇文章

订阅专栏

本文介绍了Spring框架的基本概念，包括IOC控制反转、DI依赖注入等，并详细阐述了Spring AOP的实现原理及应用步骤，同时展示了如何在Spring中配置事务传播行为。

spring学习笔记

1.srping是什么？

spring是容器框架。用于配置bean，并维护bean之间关系的框架。

Spring中有一个非常概念：bean（是java中的任何一种对象， javabean、service、action、数据源/dao、ioc（控制反转）、di（依赖注入））。

spring的框架原理图：

ioc（控制反转）：

ioc是什么？

答：ioc即（inverse of controll）控制反转：所谓控制反转就是把创建对象（bean），和维护对象（bean）的关系的权利从程序中转移到spring的容器（applicationContext.xml）中。

DI（依赖注入）：

DI是什么？

答：di（dependency injection）依赖注入：实际上di和ioc是同一个概念，spring的设计者认为di更能表示搜spring的核心技术。

从applicationContext引用上下文中获取bean和从bean中获取bean有什么不一样？

答：如果使用applicationContext，则配置的bean如果是singleton不管你用不用，都会被实例化（好处就是可以预先加载，缺点是有点耗费内存）

如果是BeanFactory，则当你实例化该对象的时候，配置的bean不会马上被实例化，当你使用的时候，才会被实例（好处就是节约内存，缺点是速度）。

规定：一般没有什么特殊要求，应当使用ApplicationContext。但是像手持设备和移动设备一般使用BeanFactory。

spring中bean的生周期：

实例化（当我们的程序加载beans.xml文件），把我们的bean（前提是scope=singleton）实例化到内存。
调用setXxxx方法设置属性。
如果你实现了bean名字关注接口（BeanNameAware）则，可以通过setBeanName获取id号
如果你实现了beanFactory关注接口（BeanFactoryAware）则，你可以获取BeanFactory
如果你实现了 ApplicationContextAware接口，则调用方法：public void setApplicationContext(ApplicationContext arg0)
            throws BeansException {

        System.out.println("ApplicationContext" + arg0);

    }
如果bean与一个后置处理器关联了，怎后置处理器会自动调用postProcessBeforeInitialization 方法；
如果你实现了InitializingBean接口，则会调用afterPropertiesSet方法
如果自己在<bean init-methed="init"/>则可以定义自己的初始化方法。
如果一个bean和一个后置处理器关联，则会自动调用postProcessAfterInitialization方法
使用我们的bean
容器关闭
可以通过实现 DisposableBean接口，来调用destroy方法
可以在<bean destory-methed="final"/>调用定制的销毁方法

小结：我们在实际的开发当中往往没有用到这么多的过程。

常见的过程是：1->2->6->9->10->11

如何给集合类型注入值：

java中的集合有list、set、map（数组）

Department类：

package com.collection;

import java.util.List;

import java.util.Map;

import java.util.Set;

public class Department {

private String name;

private String [] empName;

private List<Employee> empList;

private Set<Employee> empSets;

private Map<String, Employee> empMaps;

public Map<String, Employee> getEmpMaps() {

return empMaps;

}

public void setEmpMaps(Map<String, Employee> empMaps) {

this.empMaps = empMaps;

}

public Set<Employee> getEmpSets() {

return empSets;

}

public void setEmpSets(Set<Employee> empSets) {

this.empSets = empSets;

}

public List<Employee> getEmpList() {

return empList;

}

public void setEmpList(List<Employee> empList) {

this.empList = empList;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String[] getEmpName() {

return empName;

}

public void setEmpName(String[] empName) {

this.empName = empName;

}

employee类：

package com.collection;

public class Employee {

private String name;

private int id;

public int getId() {

return id;

}

public void setId(int id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

测试类：App1

package com.collection;

import java.util.Iterator;

import java.util.Map;

import java.util.Map.Entry;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class APP1 {

public static void main(String[] args) {

ApplicationContext ac = new ClassPathXmlApplicationContext("com/collection/beans.xml");

Department department = (Department) ac.getBean("department");

System.out.println(department.getName());

for (String emName:department.getEmpName()) {

System.out.println(emName);

}

System.out.println("***************List集合取出数据****************");

for (Employee e:department.getEmpList()) {

System.out.println("name=" + e.getName());

}

System.out.println("****************set集合取出数据****************");

for (Employee e:department.getEmpSets()) {

System.out.println("name=" + e.getName());

}

System.out.println("***************Map集合取出数据********************");

for (Entry<String, Employee> entry1:department.getEmpMaps().entrySet()) {

System.out.println(entry1.getKey() + " "+ entry1.getValue().getName());

}

System.out.println("***************迭代器集合取出数据********************");

Map<String,Employee> employees = department.getEmpMaps();

Iterator it = employees.keySet().iterator();

while(it.hasNext()){

String key = (String) it.next();

Employee emp = employees.get(key);

System.out.println("key="+ key +" " + emp.getName());

}

beans.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"

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

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

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

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

http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

<list>

</list>

</property>

<list>

</list>

</property>

<set>

</set>

</property>

<map>

</map>

</property>

</bean>

</bean>

</bean>

</beans>

aop编程

aop（aspect oriented programing）面向切面（方面）编程，是对所有的对象或者是一类对象的编程，核心是（在不增加代码的基础上，还增加新功能）。（面向N多对象编程）

aop特别提醒：aop编程，实际上在开发框架本身用的多。在实际项目中，用的不是很多，但是将来会越来越多，这是一个编程的趋势。

步骤：

1.定义接口

2.编写对象（被代理对象 = 目标对象）

3.编写通知（前置通知目标方法调用之前调用）

4.在beans.xml重配置

4.1 配置被代理对象=目标对象

4.2 配置通知

4.3 配置代理对象是ProxyFactoryBean的对象实例

4.31 配置代理接口

4.32 织入通知

4.33 配置被代理对象

提问：

说spring的aop中，当你通过代理对象去实现aop的时候，获取的ProxyFactoryBean是什么类型？

答：返回的是一个代理对象，若果目标对象实现了接口，则spring使用jdk动态代理技术。如果目标对象没有实现接口，则是spring使用cglib技术。

Spring在TransactionDefinition接口中规定了7种类型的事务传播行为，它们规定了事务方法和事务方法发生嵌套调用时事务如何进行传播：

事务传播行为类型	说明
PROPAGATION_REQUIRED	如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。
PROPAGATION_SUPPORTS	支持当前事务，如果当前没有事务，就以非事务方式执行。
PROPAGATION_MANDATORY	使用当前的事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW	新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED	以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER	以非事务方式执行，如果当前存在事务，则抛出异常。
PROPAGATION_NESTED	如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。