Spring的基础学习

柔情只为你懂 2023-10-05 21:19 40阅读 0赞

简介：spring是一个全栈式的框架，是针对bean生命周期管理的轻量级容器，提供了功能强大的IOC、AOP及webMVC等功能

## spring的IOC ##

### spring的IOC介绍 ###

IOC（inversion of Control）控制反转：控制和管理对象的权利发生了反转，之前我们需要对象，就自己new一个，现在我们将对象交给spring来管理，需要创建对象，就向spring要一个，由此看出spring管理了很多对象，一般称spring是一个对象的容器，可减少耦合度

### springIOC的实现 ###

1.  创建类，以book类为例
2.  创建工厂类bookFactory,减少耦合度
3.  创建一个配置文件，写上工厂要创建的类，工厂可创建任意对象

book01=com.jiale.beans.Book
     user01=com.jiale.beans.User
     book02=com.jiale.beans.Book

1.  创建容器，将对象放入

public class ObjectFactory{
        
    	//创建一个容器
    	private static Map<String,Object> MAP = new HashMap<>();
    	static{
        
    		try{
        
    			//创建类的时候开始创建容器,放入对象
    			//读取配置文件   --创建properties类
    			Properties p = new Properties();
    			//读取配置文件
    			p.load(new FileInputStream(new File("D:\\spring\\beans.properties")));
    			//获取properties文件中的所有key
    			for(Object key : p.keySet()){
        
    				//根据key获取value
    				String className = p.getProperty(key.toString());
    				//通过反射创建对象
    				Class aClass = Class.forName(className);
    				//创建对象
    				Object o = new aClass.newInstance();
    				//将对象放到容器中
    				MAP.put(key.toString(),o);
    			}catch(Exception e){
        
    				e.printStackTrace();
    			}		
    		}
    		public static Object createObject(String name) throws Exception{
        
    			//在容器中获取对象
    			Object o = MAP.get(name);
    			//判断是否有这个对象
    			if(o!=null){
        
    				//返回对象
    				return o;
    			}else{
        
    				System.out.println("没有这个对象");
    				return null;
    			}
    		}
    	}
    }

1.  需要使用那个类就通过工厂类调用

Book book = (Book)ObjectFactory.createObject("book01");

## springBean介绍 ##

### bean的实例化 ###

1.正常的类

<!--创建一个person对象,对象名叫person01>
     <bean id="person01" class="com.jiale.pojo.Person">

2.工厂方法  
创建一个Personfactory类

public class PersonFactory {
        
        public Person createPerson(){
        
            //创建一个对象
            Person person = new Person();
            //返回
            return person;
        }
    }

测试

//创建spring容器,读取配置文件创建
      ClassPathXmlApplicationContextac = new ClassPathXmlApplicationContext("applicationContext.xml");
      //获取person对象
      Person person = ac.getBean(Person.class);
      System.out.println(person);

3.静态工厂

public static Person createPerson(){
        
            //创建一个对象
            Person person = new Person();
            //返回
            return person;
        }

核心配置文件的配置

<bean id="person02" class="com.jiale.factory.PersonFactory" factory-method="createPerson"/>

### bean的生命周期 ###

1.scope属性的介绍

单例模式（singleton）是默认的：容器创建就初始化，容器销毁对象就销毁  
多例模式（prototype）：当在容器中获取对象的时候才会创建，创建后，容器销毁的同时也销毁  
其他属性：  
request：对象创建后就绑定到request域中  
session：对象创建后就绑定到session域中  
globalSession：如果是分布式项目，在多个项目中同时绑定session  
初始化的方法：init-method 销毁的方法：destroy-method,执行销毁的方法ac.close()

<bean id="person01" class="com.jiale.pojo.Person" init-method="csh" destroy-method="xh"/>

## springDI（依赖注入） ##

必须在springIOC容器中的对象才可以处理依赖，依赖注入简单来说就是属性的注入

### 构造方法注入 ###

使用构造方法注入必须要有多参数的构造方法  
配置文件：

### set方法注入 ###

使用set方法必须要有空参的构造方法,必须有属性对应的set方法

### 复杂属性的注入 ###

1.属性是对象

2.属性是数组

3.属性是list集合

4.属性是map集合

## spring的配置文件 ##

### 整合jdbc ###

### 整合数据源c3p0 ###

## spring的注解 ##

在使用注解的时候要在配置文件中添加扫描注解的路径

<context:component-scan base-package="com.jiale"/>

### 常用注解的介绍 ###

IOC的注解：注解都是加在类的上面  
@Component：除了三以外的地方  
@Controller：控制层注解（表现层）  
@Service：业务层注解  
@Repository：持久层注解  
作用都是一样的，相当于在配置文件中添加了bean标签，把该类添加到配置文件中

DI注解  
@Value：为容器中的属性添加值（只能添加基本数据和字符串）,可以添加在set方法上，也可以添加在属性上面，添加在属性上面，没有set方法也可以直接赋值

@Value("3")
        private int id;

@Autowired：引用数据类型的注入，需要注入的引用数据类型，必须保证注入的类型在spring中有实例
    	Autowired的作用：根据类型在容器中查找对象，如果找到一个，就会将对应的的实例注入到对象中，如果找到一个以上，会根据属性名来判断注入到哪一个实例中，如果有属性名和实例的id一致，就会注入，若没有就会抛出异常

@Autowired
        private Dog dog;

@Qualifier：不能单独使用，需要配合Autowired使用，添加在Autowired下面

@Autowired
    	@Qualifire("dog02")
        private Dog dog;

@Resource：效果等同于@Autowired + @qualifier 注解，如果只使用注解不添加属性，作用和@Autowired 一样

spring-test的使用 spring整合junit的使用

@RunWith(SpringJUnit4ClassRunner.class)//通过junit对应的注解运行spring的容器
    @ContextConfiguration("classpath:applicationContext.xml")//读取spring的核心配置文件来创建spring容器
    public class Test {
        
        @Autowired
        Dog dog;
        @org.junit.Test
        public void test01(){
        
            System.out.println(dog);
        }
    }

### 其他注解 ###

@Configuration：该注解写在类的上面，表明该类是一个注解类，spring在读取类的时候就会在类中读取对应的配置  
@Bean：该注解是添加在方法上面的，方法的返回值就相当于配置了一个bean标签，将方法的返回值放入到spring容器中  
@componentScan：该注解是写在类上的，相当于在核心配置文件中配置springIOC注解的扫描

@Configuration   //这是一个配置文件类
    @ComponentScan(basePackages = "com.offcn")  //扫描springIOC注解
    	//配置dataSource
        @Bean(name = "dataSource")
        public DataSource getDataSource(){
        
            //创建一个jdbc里面的datasource
            DriverManagerDataSource dataSource = new DriverManagerDataSource();
            //设置驱动
            dataSource.setDriverClassName("com.mysql.jdbc.Driver");
            //设置url
            dataSource.setUrl("jdbc:mysql:///mybatis");
            //设置用户名
            dataSource.setUsername("root");
            //设置密码
            dataSource.setPassword("root");
            //返回数据源
            return dataSource;
        }

## springAOP ##

AOP （Aspect Orineted Progamming） 面向切面编程：通过编译和运行期间动态代理实现程序和功能统一维护的一种技术  
AOP研究的不是每一层要如何开发，而是研究同一层模块之间的共性功能  
将批量需要添加的功能和程序，通过AOP的方式横向的添加到原有的代码中。使用AOP的模式，不需要更改原有的代码，是通过底层运行机制动态的将内容添加到代码中。

### 名词解释 ###

1.连接点（join point）：程序运行的一些时间点，比如方法执行前的点、方法执行后的点、出现异常的点，连接点只有方法才有  
2.切点（point out）：AOP中提供了一组规则，按照固定的规则去切（匹配）连接点，匹配出来的就叫切点，AOP中切点的规则用切点表达式来表示，切点的最小单位是方法  
3.增强（Advicr）：需要在原有的代码上添加的内容，可以将增强称为通知，分为前置通知、后置通知、最终通知、异常通知、环绕通知  
4.织入（Weaving）：这是一个过程，将增强添加到核心代码的过程  
5.目标对象（target）：在原有的代码上经过织入新生成的对象  
6.切面（Aspect）：在AOP中切面是一个概念，里面包含增强和切点，也可以说切面=增强+切点，增强中定义新增的内容，定义增强在什么连接点执行。切点定义在什么地方切入，也就是说，切面定义的是什么样的增强功能，切入到哪个核心方法的位置

### AOP的工作流程 ###

开发阶段：  
正常代码开发–>发现共性功能，需要添加，制作增强–>开发完增强后，制作切点–>在配置文件中声明增强和切点的关系，形成切面  
运行阶段：  
JVM读取配置文件，会对切点进行解析监控，一旦切点对应的方法被执行，使用动态代理机制生成目标对象，执行

### 通知的类型 ###

前置通知：增强是添加在方法前面  
后置通知：增强是添加在方法后面  
异常通知：增强是添加在方法出现异常后  
最终通知：无论方法有何异常，都会执行，类似于try-catch-finally中的finally  
环绕通知：自己设置增强添加到什么位置,一般使用的时候，环绕通知是单独使用的

//环绕通知的实例
    Object ret = null;
    try{
        
    	//添加事务开启----前置通知
    	TXUtils.begin();
    	//调用被代理对象的方法
    	ret = methodProxy.invokeSuper(o,objects);
    	//提交事务----后置通知
    	TXUtils.commit();
    }catch(Throwable throwable ){
        
    	//异常通知
    	throwable.printStackTrace();
    	//回滚事务
    	TXUtils.rollback();
    }finally{
        
    	//最终通知
    	System.out.println("最终通知");
    }

### 切点表达式 ###

在配置文件中使用关键字execution()里面表示的表达式  
完整的切点表达式  
void com.jiale.dao.PersonDaoImpl.editPerson()  
表达式可以用模糊匹配来完善  
\*：表示任意多个字符的匹配  
…：匹配一级或者多级包的路径

<aop:pointcut id="pc" expression="execution(* com.jiale..PersonDaoImpl.editPerson())"/>
    
    <aop:pointcut id="pc" expression="execution(* com.jiale..PersonDaoImpl.editPerson(..))"/>

常用的表达式：事务表达式:

* com.jiale.service..*Impl.*(..)

### AOP在配置文件中的配置 ###

1.添加AOP的头

xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/aop
    	http://www.springframework.org/schema/aop/spring-aop.xsd"

2.配置aop

<bean id="myAdvice" class="com.jiale.advice.MyAdvice"/>
    
    <aop:config>
        
        <aop:pointcut id="pc" expression="execution(* com.jiale.dao.PersonDaoImpl.editPerson())"/>
        
        <aop:aspect ref="myAdvice">
            
            <aop:before method="before" pointcut-ref="pc"/>
        </aop:aspect>
    </aop:config>

3.配置通知类型  
前提：在增强类中有通知的方法

<aop:config>
        
        <aop:pointcut id="pc" expression="execution(* com.jiale.dao.*Impl.*(..))"/>
        
        <aop:aspect ref="myAdvice">
            
            <aop:before method="before" pointcut-ref="pc"/>
            
            <aop:after-returning method="afterRunning" pointcut-ref="pc"/>
            
            <aop:after-throwing method="runExcept" pointcut-ref="pc"/>
            
            <aop:after method="after" pointcut-ref="pc"/>
        </aop:aspect>
    </aop:config>

<aop:around method="around" pointcut-ref="pc"/>

4.springAOP使用注解配置  
前提：配置文件中要配置

<aop:aspectj-autoproxy/>

@Component  //将当前的类交给spring容器
    @Aspect  //将当前类设置为通知类
    public class MyAdvice {
        
        //将表达式提前出来
        @Pointcut("execution(* com.jiale.dao.*Impl.*(..))")
        public void pc(){
        }
        //前置的通知
        @Before("execution(* com.jiale.dao.*Impl.*(..))")
        public void before(){
        System.out.println("前置通知"); }
    }

后置通知：@AfterReturning()  
异常通知：@AfterThrowing  
最终通知：@After  
环绕通知：@Around

### springAOP对事务的支持 ###

#### 数据库中的事务 ####

数据库在访问的时候，可以将各种操作绑定在一起合并成一个事务，当事务创建后，事务中所有的SQL语句都是一个整体，要么都成功，要么都失败。事务中的开启和结束都是数据库的行为  
事务的特性：  
原子性：比喻事务是一个完整不可分割的整体  
一致性：事务中的所有sql执行的结果都是一致的  
隔离性：事务和其他事务之间是相互隔离的，互不影响  
持久性：事务的结果对数据库造成改变，数据会发生永久改变。innoDB数据库引擎，只有该引擎具有事务作用

#### spring中的事务 ####

spring框架中，事务可以使用两种方法来完成：  
编程式事务：相当于将事务的代码添加到项目的代码中  
优点：可以做到代码块级别的事务管理，精细度高 缺点：繁琐  
声明式事务：相当于在配置中设置事务，代码中没有对应的事务  
优点：只需要在配置文件中设置即可，将事务和代码分隔开，通过springAOP实现 缺点：只能控制方法级别的事务

#### spring-tx事务管理 ####

在spring框架中有一个模块专门做事务管理spring-tx，作用就是事务管理。使用aop的方式实现事务管理。  
在spring-tx模块中为了管理事务，专门创建了一个类  
1.事务管理平台：不同的数据库连接框架、工具使用不同的平台管理。  
2.事务的运行状态：TransactionStauts 事务状态类  
作用：查看事务的状态 事务是否有回滚点、是否是只回滚事务、可以刷新事务的状态。  
3.事务设置的类：TransactionDefinition 事务设置的类，可以设置事务的状态、事务只读、隔离级别等设置  
核心配置文件配置事务  
1.添加spring-tx的头

xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx.xsd"

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
           
           <property name="dataSource" ref="dataSource"/>
       </bean>
       
       <tx:advice id="tx-advice" transaction-manager="transactionManager">
           
           <tx:attributes>
               <tx:method name="transferAccounts"/>
           </tx:attributes>
       </tx:advice>
       
       <aop:config>
           
           <aop:advisor advice-ref="tx-advice" pointcut="execution(* com.jiale.service..*Impl.*(..)"/>
       </aop:config>

<tx:attributes>
        
        <tx:method name="add*"/>
        <tx:method name="save*"/>
        <tx:method name="insert*"/>
        <tx:method name="update*"/>
        <tx:method name="edit*"/>
        <tx:method name="del*"/>
        <tx:method name="drop*"/>
        <tx:method name="find*" read-only="true"/>
        <tx:method name="get*" read-only="true"/>
        <tx:method name="select*" read-only="true"/>
        <tx:method name="query*" read-only="true"/>
    </tx:attributes>