spring

最新推荐文章于 2024-09-21 00:43:01 发布

何须低头

最新推荐文章于 2024-09-21 00:43:01 发布

阅读量213

点赞数

分类专栏： spring框架文章标签： spring

本文链接：https://blog.csdn.net/qq_38342614/article/details/79497646

版权

spring框架专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Day_01 Spring入门

<!-- id是bean的标识符,必须唯一,如果没有配置id,name默认为标识符

　　如果配置了id,有配置了name,那么name为别名

name可以设置多个别名,分隔符可以是空格逗号分号

class是bean的全限定名,即包名加类名

如果不配置id和name,那么可以根据applicationContext.getbean(Class)获取对象,

　　　scope:bean的作用域,

　　　　　　取值:singleton:单例的,整个容器只产生一个对象,默认是单例

　　　　　　　　 prototype:原型,每次获取bean都创建一个新对象

　　　　　　　　 request:每次请求时创建一个新的对象

　　　　　　　　 session:在一个会话范围内只产生一个对象

　　　　　　　　 application:在应用范围内是一个对象

autowire:自动装配用于简化spring的配置

　　　　　　取值:byname:根据名称(根据set方法中set后面的内容)去查找相应的bean,发现了则装载上

　　　　　　　　 bytype:根据类型自动装配,不用去管id,但同一种类型的bean只能有一个,f否则报错

　　　　　　　　 constructor,当通过构造器注入实例化bean时,装配构造方法

-->

</bean>

今天学习内容

l 学习哪些Spring框架中技术

l 快速了解Spring框架搭建

l 快速测试Spring框架

l Spring框架中IOC和DI概念

1、学习Spring框架中哪些技术

l Spring中IOC

l Spring中AOP

l Spring中DataAccess

l Spring中Web开发，SpringMVC

l Spring中注解

l Spring配置文件

2、Spring框架搭建

l 导入Spring包

Ø spring.jar：包含很多Spring框架功能模块包，如：orm，web，aop

Ø common-logging.jar：spring框架在运行BeanFacotry时候需要的依赖包（简单理解就是运行Spring框架的依赖包）

l Spring的整体功能体系架构图

l Spring IOC概念

Ø 所有的Java类（不管是JDK库中Java类，还是你自己定义Java类）都可以利用Spring框架来new它们的实例化对象

Ø Spring框架完成对Java类的初始化对象工作

l 配置spring.xml文件，其实spring.xml文件就是Spring框架中的容器

<?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">

<import resource="spring-day01.xml"/> <!- import：分成小类-à

</beans>

<?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">

<bean id="person" class="com.gxa.spring.day01.Person"></bean><!—配置java对象-à

</beans>

l 测试Spring框架的应用程序，使用BeanFactory来完成

package com.anhen.day01;

public class Person {

private String name;

public void setName(String name){

this.name = name;

}

public String getName(){

return name;

}

package com.gxa.spring.test01;

import org.junit.Test;

import org.springframework.beans.factory.BeanFactory;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.gxa.spring.day01.Person;

public class Test01 {

@Test

public void m01() {

/**

* 运行Spring框架需要用到BeanFactory

* 1.BeanFactory帮助我们启动IOC容器

* 2.帮助我们找到需要实例化Java对象

BeanFactory beanFactory = new ClassPathXmlApplicationContext("spring.xml");

Person person = (Person) beanFactory.getBean("person");

person.setName("Hello World");

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

}

3、Spring的IOC和DI

l Spring中IOC和DI其实概念一样

l IOC控制反转，所有的Java类的初始化工作扔给Spring框架。Spring框架充分利用Java反射

l DI依赖注入，一个Java类如果依赖其他Java类，则此类依赖另一个Java类的初始化工作也扔给Spring框架来完成

Ø 通过从MVC分层开发角度去理解一下DI

Ø Controller控制器依赖Service，假设整个Web开发过程中我们使用Spring框架，则Serivce的初始化工作时Controller不用关心Service对象是如何创建的，Service创建过程扔给Spring框架

l DI和IOC程序实现的原理是什么

4、Spring充当管理作用

Day_02 Spring基础部分的学习

今天学习内容

l 了解BeanFactory中的getBean方法

l Spring依赖注入的两种方式（构造方法注入和setter方式注入）

l p-namespace方式配置（用于简化<property>）

l properties属性文件配置方式

l 集合对象配置方式

l Bean scopes作用域（单例作用域和原生作用域）

l Spring中Annotation注解使用

1、BeanFactory中genBean方法

l getBean(String name): 获取对象，但是需要类型转换

BeanFactorybeanFactory = new ClassPathXmlApplicationContext("spring.xml");

Person person = (Person) beanFactory.getBean("person");//spring框架已经实例化了类

l getBean(String name, Class<T> clazz)：获取对象，无需类型转换

PetServiceImpl pet = applicationContext.getBean("petService",PetServiceImpl.class);

l BeanFactory是获取注入到Spring容器中对象的工厂类。ApplicationContext是BeanFactory子接口

l 注意

Ø 如果使用getBean(String name, Class<T> clazz)方法一定要关注Spring框架版本

Ø 如果使用spring.4.0.3版本导包要包含（spring-core.jar,spring-beans.jar, spring-context.jar, spring-expression.jar, common-logging.jar）

2、Spring依赖注入方式

l 构造方法注入

Ø 先定义好依赖对象

Ø 再去定义构造方法，然后在构造方法的参数中去为依赖对象赋值

Ø 在配置文件中<constructor-arg>（通过构造函数注入）

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

xsi:schemaLocation="http://www.springframework.org/schema/beans

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

<constructor-arg name="petDao" ref="petDao"></constructor-arg>

</bean>

</beans>

public class PetServiceImpl {

private PetDaoImpl petDao;//依赖对象

public PetServiceImpl(PetDaoImpl petDao){//构造方法

this.petDao = petDao;

}

public void selectPet(){

petDao.selectPet01();

}

l 设置（Setter）方式注入

Ø 先定义好依赖对象

Ø 给依赖对象只添加setter方法

Ø 在配置文件中使用<property>（通过setter对应的方法注入）标签就OK了

<?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">

</bean>

</beans>

public class PetServiceImpl {

private PetDaoImpl petDao;//依赖对象== PetDaoImpl petDao=new PetDaoImpl();(实例化由配置文件完成)

private ItemDaoImpl itemDao;//依赖对象== ItemDaoImpl itemDao =new ItemDaoImpl ();(实例化由配置文件完成)

//set方式注入

public void setPetDao(PetDaoImpl petDao){//没有此set方法则不能依赖注入

this.petDao = petDao;

}

public void setItemDao(ItemDaoImpl itemDao) {//没有此set方法则不能依赖注入

this.itemDao = itemDao;

}

public void selectPet(){

petDao.selectPet();//调用的PetDaoImpl类中的方法

itemDao.selectItem();//调用的ItemDaoImpl类中的方法

}

3、p-namespace配置方式

l 主要去简化<property>标签的配置

l 要使用p-namespace需要在整个配置文件声明部分加入p-namespace的XMLSchema定义

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

xsi:schemaLocation="http://www.springframework.org/schema/beans

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

<constructor-arg name="petDao" ref="petDao"></constructor-arg>

</bean>

<bean id="person" class="com.gxa.spring.day02.Person" p:petDao-ref="petDao"></bean>

</beans>

4、properties属性文件配置(数据库配置文件)

l <bean class=”org.springframework.beans.factory.config.PropertyPlaceholderConfiguer”>来解析Java中属性文件

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

xsi:schemaLocation="http://www.springframework.org/schema/beans

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

<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

<property name="locations" value="jdbc.properties"></property>

</bean>

<constructor-arg name="petDao" ref="petDao"></constructor-arg>

</bean>

<bean id="dbConnection" class="com.gxa.spring.day02.DBConnection"

p:username="${mysql.username}"

p:password="${mysql.password}"

p:driver="${mysql.driver}"></bean>

</beans>

l <context:property-placeholder location=”jdbc.properties”>来解析Java中属性文件

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

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

xsi:schemaLocation="http://www.springframework.org/schema/beans

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

http://www.springframework.org/schema/context

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

<context:property-placeholder location="jdbc.properties"/>

<constructor-arg name="petDao" ref="petDao"></constructor-arg>

</bean>

<bean id="dbConnection" class="com.gxa.spring.day02.DBConnection"

p:username="${mysql.username}"

p:password="${mysql.password}"

p:driver="${mysql.driver}"></bean>

</beans>

5、集合对象的配置

l <list>,<Map>,<Set>,<Props>

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

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

xsi:schemaLocation="http://www.springframework.org/schema/beans

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

http://www.springframework.org/schema/context

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

</bean>

<constructor-arg name="petDao" ref="petDao"></constructor-arg>

</bean>

<bean id="dbConnection" class="com.gxa.spring.day02.DBConnection"

p:username="${mysql.username}"

p:password="${mysql.password}"

p:driver="${mysql.driver}"></bean>

<property name="list">

<list>

<value>Hello World</value>

<ref bean="dbConnection"/>

</list>

</property>

<property name="map">

<map>

<entry key="key01" value="Hello World"></entry>

<entry key="key02" value-ref="dbConnection"></entry>

</map>

</property>

<property name="set">

<set>

<value>Hello World</value>

<ref bean="dbConnection"/>

</set>

</property>

<property name="props">

<props>

<prop key="key01">Hello World</prop>

<prop key="key02">liuyang</prop>

</props>

</property>

</bean>

</beans>

package com.gxa.spring.day02;

import java.util.Enumeration;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Properties;

import java.util.Set;

public class CollectionsSpring {

private List<?> list;

private Map<String,?> map;

private Set<?> set;

private Properties props;

public void setList(List<?> list) {

this.list = list;

}

public void setMap(Map<String, ?> map) {

this.map = map;

}

public void setSet(Set<?> set) {

this.set = set;

}

public void setProps(Properties props) {

this.props = props;

}

public void showList() {

for (int i = 0; i < list.size(); i++) {

System.out.println(list.get(i));

}

public void showMap() {

System.out.println(map);

}

public void showSet() {

Iterator<?> iterator = set.iterator();

while(iterator.hasNext()) {

System.out.println(iterator.next());

}

public void showProps() {

Enumeration<?> enumeration = props.propertyNames();

while(enumeration.hasMoreElements()) {

System.out.println(props.getProperty(enumeration.nextElement().toString()));

}

package com.gxa.spring.test02;

import org.junit.Test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.gxa.spring.day02.CollectionsSpring;

import com.gxa.spring.day02.DBConnection;

import com.gxa.spring.day02.Person;

import com.gxa.spring.day02.PetServiceImpl;

public class Test01 {

@Test

public void m04() {

ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");

CollectionsSpring collectionsSpring = context.getBean("collectionsSpring", CollectionsSpring.class);

collectionsSpring.showList();

collectionsSpring.showMap();

collectionsSpring.showSet();

collectionsSpring.showProps();

}

6、Bean Scopes作用域

l Singleton：单例作用域，Spring容器初始化对象只有唯一个（默认）

l Prototype：原生作用域，每次调用Spring容器的getBean方法都会重新产生一个新的对象

l Request

l Session

l Global Session

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

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

xsi:schemaLocation="http://www.springframework.org/schema/beans

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

http://www.springframework.org/schema/context

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

<list>

<value>Hello World</value>

</list>

</property>

<map>

</map>

</property>

<set>

<value>Hello World</value>

</set>

</property>

<props>

<prop key="key01">Hello World</prop>

<prop key="key02">liuyang</prop>

</props>

</property>

</bean>

</beans>

package com.gxa.spring.test02;

import org.junit.Test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.gxa.spring.day02.CollectionsSpring;

import com.gxa.spring.day02.DBConnection;

import com.gxa.spring.day02.Person;

import com.gxa.spring.day02.PetServiceImpl;

public class Test01 {

@Test

public void m05() {

ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");

CollectionsSpring collectionsSpring01 = context.getBean("collectionsSpring", CollectionsSpring.class);

CollectionsSpring collectionsSpring02 = context.getBean("collectionsSpring", CollectionsSpring.class);

System.out.println(collectionsSpring01.hashCode());

System.out.println(collectionsSpring02.hashCode());

}

7、Spring的Annotation

l Spring的注解是在Spring2.5的版本中引入的，目的简化XML配置

l Spring常用的注解

Ø @Component

Ø @Autowired

Ø @Qualifier

Ø @Scope

Ø @Controller

Ø @Service

Ø @Repository

8、@Component注解

l @Component主要用于将一个Java类注入到Spring框架中，它相当于XML配置文件中的<bean id=”xxx” class=”xxx”/>

l 当使用了Spring注解后，我们需要在配置文件中添加<context:component-scan/>来扫描添加了注解的类，这样子声明注解的类才能起作用

l 同时需要关注Spring框架需要加入的包【很重要】

Ø common-logging.jar

Ø spring-core-4.0.3.jar

Ø spring-context-4.0.3.jar

Ø spring-beans-4.0.3.jar

Ø spring-expression-4.0.3.jar

Ø spring-aop-4.0.3.jar【在使用<context:component-scan/>需要导入此包】

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

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

xsi:schemaLocation="http://www.springframework.org/schema/beans

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

http://www.springframework.org/schema/context

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

<context:component-scan base-package="com.gxa.spring.day02"></context:component-scan>

</bean>

<constructor-arg name="petDao" ref="petDao"></constructor-arg>

</bean>

<bean id="dbConnection" class="com.gxa.spring.day02.DBConnection"

p:username="${mysql.username}"

p:password="${mysql.password}"

p:driver="${mysql.driver}"></bean>

<list>

<value>Hello World</value>

</list>

</property>

<map>

</map>

</property>

<set>

<value>Hello World</value>

</set>

</property>

<props>

<prop key="key01">Hello World</prop>

<prop key="key02">liuyang</prop>

</props>

</property>

</bean>

</beans>

package com.gxa.spring.day02;

import org.springframework.stereotype.Component;

@Component

public class StudentAnnotation {

}

/*===============================================================================================================*/

package com.gxa.spring.test;

import org.junit.Test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.gxa.spring.day02.StudentAnnotation;

public class Test02 {

@Test

public void m06() {

ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");

StudentAnnotation studentAnnotation = context.getBean("studentAnnotation", StudentAnnotation.class);

System.out.println(studentAnnotation.hashCode());

}

l 除了@Component注解，Spring容器提供了3个功能和@Component注解等同。它们分别是用于对Dao，Service及Web层的Controller进行注解

Ø @Repository：用于对Dao实现类注解

Ø @Service：用于对Service实现类注解

Ø @Controller：用于对Controller实现类注解

9、@Autowired注解

l Spring2.5引入了@Autowired注释，它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作

l Spring通过@Autowired注解实现Bean之间的依赖关系

package com.gxa.spring.day02;

import org.springframework.stereotype.Component;

@Component

public class TeacherAnnotation {

public void getTeacherName() {

System.out.println("===刘老师好===");

}

/*===============================================================================================================*/

package com.gxa.spring.day02;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;

@Component

public class StudentAnnotation {

/**

* 通过Autowired来自动装备Student所依赖的对象

* 无需创建setter方法

* 无需编写XML配置文件中<property/>

@Autowired

private TeacherAnnotation teacherAnnotation;

public void showTeacher() {

teacherAnnotation.getTeacherName();

}

l @Autowired(required = false), 告诉 Spring：在找不到匹配 Bean 时也不报错

package com.gxa.spring.day02;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;

@Component

public class StudentAnnotation {

/**

* 注意TeamAnnotation没有加入@Component

* 当StudentAnnotation依赖TeamAnnotation会报错

* 但是如果加入@Autowired(required=false)就不会报错

@Autowired(required=false)

private TeamAnnotation teamAnnotation;

public void showTeacher() {

teacherAnnotation.getTeacherName();

}

10、@Qualifier指定注入Bean的名称

l 如果容器中有一个以上匹配的Bean时，则可以通过@Qualifier注解限定注入的Bean名称

package com.gxaedu.bean;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.stereotype.Component;

@Component

public class Computer {

@Autowired

@Qualifier("storage01")

private Storage storage;

public void m01() {

storage.show();

}

/*===============================================================================================================*/

package com.gxaedu.bean;

import org.springframework.stereotype.Component;

@Component("storage01")

public class Storage { //此类是在com.gxaedu.bean下的Storage

public void show() {

System.out.println("东芝硬盘");

}

/*===============================================================================================================*/

package com.gxaedu.test;

import org.springframework.stereotype.Component;

@Component

public class Storage { //此类是在com.gxaedu.test下的Storage

}

11、@Qualifier为方法指定注入Bean名称

package com.gxa.spring.day02;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.stereotype.Component;

@Component

public class StudentAnnotation {

private CourseAnnotation courseAnnotation;

/**

* @Autowired来自动装备构造方法里面的对象

* @Qualifier来指定依赖对象的bean

* @param courseAnnotation

@Autowired

public StudentAnnotation(@Qualifier("course") CourseAnnotation courseAnnotation) {

this.courseAnnotation = courseAnnotation;

}

public void showCourse() {

System.out.println(courseAnnotation.hashCode());

}

12、@Scope注解来显式指定Bean作用范围

@Scope("prototype")

@Component

public class Car {

}

Day_03 Spring的AOP, DataAccess介绍

今天学习内容

l Spring的AOP介绍（包括XML方式配置和注解方式配置）

l Spring的DataAccess介绍，重点对JDBC整合

l Spring的事务管理

1、Spring AOP面向切面编程入门

l AOP为Aspect Oriented Programming的缩写，含义：面向切面的切面。它是对OOP的有力补充。

l 主要的功能是：日志记录，性能统计，安全控制，事务处理，异常处理等等。

l 主要的意图是：将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来

2、有关Spring中AOP的概念

l 切面，Aspect：关注点

l 连接点，Join Point：程序执行过程中的某一点

l 建议，Advice：AOP框架在特定的连接点上执行的动作

l 切入点，Pointcut：一系列连接点的集合

l 目标对象，Target object：要被代理的对象

l AOP代理，AOP Proxy：AOP框架创建的对象，Spring中的AOP代理包含JDK动态代理和CGLIB代理，前者为接口代理（实现接口的目标对象代理），后者为类代理

l 引入，Introduction：简单说就是AOP中的方法

3、建议的分类

l Before Advice

l After Advice

l Around Advice

4、简单日志记录AOP实现

l 创建一个记录日志的AOP

package com.spring.aop;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Before;

import org.springframework.stereotype.Component;

@Aspect

public class LogAop {

@Before("execution(public void com.spring.dao.impl.StudentDaoImpl.*(..))")

public void logBefore() {

System.out.println("方法执行之前转载日志");

}

l 创建一个StudentDao接口

package com.spring.dao;

public interface StudentDao {

public void insert();

}

l 创建实现StudentDao接口的类

package com.spring.dao.impl;

import com.spring.dao.StudentDao;

public class StudentDaoImpl implements StudentDao {

@Override

public void insert() {

System.out.println("method insert");

}

l 创建一个Service类

package com.spring.services;

import com.spring.dao.StudentDao;

public class StudentServices {

private StudentDao dao;

public void setDao(StudentDao dao) {

this.dao = dao;

}

public void insert() {

dao.insert();

}

l 创建一个JUnit测试类

package com.spring.junit;

import static org.junit.Assert.*;

import org.junit.Test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.spring.dao.StudentDao;

import com.spring.services.StudentServices;

public class Test_AOP {

@Test

public void testInsert() {

ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");

StudentServices ss = (StudentServices) ac.getBean("studentServices");

ss.insert();

}

l 创建bean-aop-annotation.xml文件，此文件开启一个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:p="http://www.springframework.org/schema/p"

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

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

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</bean>

</bean>

</beans>

5、Spring AOP注解详细介绍

l Spring AOP注解应用必须满足如下的事项

Ø 导入Aspectj的jar、Spring3.0-AOP.jar、aopalliance.jar即可

Ø 需要在配置文件中加入注解的配置，例如：bean-aop-annotiation.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:p="http://www.springframework.org/schema/p"

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

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

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

如果使用Spring AOP注解，最好的用处就是减少在配置文件中的AOP内容。但是如果要掌握好Spring的AOP还需要学习注解的语法，下面的内容会给大家慢慢介绍

6、织入点语法

package com.spring.aop;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Before;

import org.springframework.stereotype.Component;

@Aspect

public class LogAop {

@Before("execution(public void com.spring.dao.impl.StudentDaoImpl.*(..))")

public void logBefore() {

System.out.println("方法执行之前转载日志");

}

而execution(public void com.spring.dao.impl.StudentDaoImpl.*(..))，这个就是织入点的语法，它告诉AOP框架哪个类中方法需要进行AOP

7、execution语法介绍

l execution(public * *(..))

l execution(* set*(..))

l execution(* com.xyz.service.AccountService.*(..))

l execution(* com.xyz.service..*.*(..))

l 语法格式：

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?)

l 注意：上面的是Aspectj的语法，因为Spring的AOP中加入强大的Aspectj框架作为支撑

8、Spring AOP注解例子

l @Before前置建议，它是在执行一个业务方法之前插入的切面

l @AfterReturning，它是当一个方法正常运行后，执行的切面

l @After，它是当方法执行成功或者出现异常的时候都会执行切面

l @Around，它相当于一个AOP链，如果当前AOP执行后，就让下一个AOP执行

l @AfterThrowing，如果在方法中有错误抛出，则执行此建议

package com.spring.aop;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Before;

import org.springframework.stereotype.Component;

@Aspect

public class LogAop {

@Before("execution(public void com.spring.dao.impl.StudentDaoImpl.*(..))")

public void logBefore() {

System.out.println("方法执行之前转载日志");

}

@AfterReturning("execution(public void com.spring.dao.impl.StudentDaoImpl.insert(..))")

public void logAfterReturning() {

System.out.println("方法执行返回后载入日志");

}

@After("execution(public * com.spring.dao.impl.StudentDaoImpl.*(..))")

public void logAfter() {

System.out.println("Finally载入日志");

}

@Around("execution(public * com.spring.dao.impl.StudentDaoImpl.*(..))")

public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {

System.out.println("===around建议载入日志===" + new Date());

Object o = pjp.proceed();

return o;

}

@AfterThrowing("execution(public * com.spring.dao.impl.StudentDaoImpl.*(..))")

public void logAfterThrowing() {

System.out.println("===有参数异常载入日志===" + new Date());

}

9、Spring AOP基于XML文件配置介绍

l 一般情况下如果不想使用注解的方式来声明AOP，我们可以采用基于XML配置文件的方法来进行配置

l <aop:config.../>，此标签很重要。它是在XML里配置AOP功能的核心标签

Ø all aspect and advisor elements must be placed within an<aop:config> element

Ø An <aop:config> element can contain pointcut, advisor, andaspect elements

l 如果要使用<aop:config…/>一定要把AOP中一些俗语和概念搞懂【很重要】

10、下面给出如何基于XML配置AOP

l 创建LogAopXML的切面

package com.spring.aop;

import java.util.Date;

public class LogAopXML {

public void logBefore() {

System.out.println("==基于XML的AOP前置建议==" + new Date());

}

l 创建bean-aop-xml.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:p="http://www.springframework.org/schema/p"

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

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

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

<aop:config>

<aop:aspect id="myAspect" ref="logAopXML">

<aop:pointcut expression="execution(* com.spring.dao.impl.TeacherDaoImpl.*(..))" id="businessService"/>

<aop:before pointcut-ref="businessService" method="logBefore"></aop:before>

</aop:aspect>

</aop:config>

</bean>

</beans>

上述代码中

<aop:config>，主要是配置存放切面，切入点，建议

<aop:aspect>，主要是配置切面类，一般需要制定好id,ref这两个属性

<aop:pointcut>，主要配置切入点，描述切入点规则

<aop:before>，主要配置的是前置建议

l 通过JUnit来进行单元测试

@Test

public void testLogAopXml() {

ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");

TeacherService ts = (TeacherService)ac.getBean("teacherService");

ts.insert();

}

11、Spring对Dao的支持

l Spring对JDBC的支持

l Spring对ORM框架的支持

l 重点先介绍Spring对JDBC支持。在Spring对JDBC支持中提供了一个模板JdbcTemplate，此模板封装了对JDBC操作的许多方法，且消除了忽视资源释放而引起的漏洞

l 后期Spring与MyBatis的整合我们在项目中告诉大家

l 需要导入的支持Spring对Jdbc封装包

Ø common-dbcp.jar：提供数据源的第三方包

Ø common-pool.jar： common-dbcp.jar的依赖包

Ø spring-jdbc-4.0.3.jar：完成jdbc操作

Ø spring-tx-4.0.3.jar：jdbc事务异常相关类

Ø msyql-connector.jar：mysql的驱动包

12、我们来看一个应用Spring JDBC的程序编写步骤

l 配置数据源

l 数据源的配置Spring依赖于第三方两个数据源实现包：Apache-DBCP和C3P0。所以我们在配置数据源的时候可以任选其中一个

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"

destroy-method="close"

p:driverClassName="com.mysql.jdbc.Driver"

p:url="jdbc:mysql://localhost:3306/sampledb"

p:username="root"

p:password="1234" />

l 注意事项：BasicDataSource提供了close方法来关闭数据源，所以我们可以利用destory-method属性来执行关闭操作

l DBCP参数说明

Ø initialSize：初始化连接，即连接池启动时候创建的初始化连接数量。默认为0

Ø maxActive：最大活动连接，即连接池在同一时间能够分配的最大活动连接的数量，如果设置为负数则表示不限制。默认为8

Ø maxIdle：最大空闲连接，即连接池允许保持空闲状态的最大连接数量，超过的空闲连接将被释放，如果设置为负数表示不限制。默认为8

Ø minIdle：最小空闲连接，即连接池允许保持空闲状态的最小连接数量，低于这个数量将创建新的连接，如果设置为0则不创建。默认为0

Ø maxWait：最大等待时间，即当没有可用连接时，连接池等待连接被归还的最大时间（单位：以毫秒计数），超过时间则抛异常。如果设置为-1表示无限制。默认为-1

l 结合属性文件进行数据源的配置

先创建jdbc.properites文件

jdbc.driverClassName=oracle.jdbc.driver.OracleDriver

jdbc.url=jdbc:oracle:thin:@localhost:1521:XE

jdbc.username=team3

jdbc.password=team3

在Spring的配置文件中可以编写如下的代码

<context:property-placeholder location="classpath:jdbc.properties">

</bean>

l JdbcTemplate模板应用

l 一般情况，我们在Dao类中使用JdbcTemplate，JdbcTemplate在XML配置文件配置好后，然后直接在Dao中注入

package com.gxaedu.dao;

import java.util.List;

import java.util.Map;

import org.springframework.jdbc.core.JdbcTemplate;

@Repository //声明一个Dao

public class UsersDao {

@Autowire //注入jdbcTemplate

JdbcTemplate template;

public void query() { //用户的查询

String sql = "select * from users";

List<Map> list = template.queryForList(sql);

System.out.println("list = " + list);

}

public Map query(String username, String userpwd) {

//获取用户信息的操作还是使用Spring的JDBC

String sql = "select * from users where user_name = ? and user_pwd = ?";

Object[] obj = {username, userpwd};

return template.queryForMap(sql, obj);

}

l JdbcTemplate模板提供操作数据库的方法应用

例如：

int rowCount = this.jdbcTemplate.queryForInt("select count(0) from t_accrual"); //返回一个int值

int countOfActorsNamedJoe = this.jdbcTemplate.queryForInt(

"select count(0) from t_actors where first_name = ?", new Object[]{"Joe"}); //通过参数的绑定来返回int值

String surname = (String) this.jdbcTemplate.queryForObject(

"select surname from t_actor where id = ?",

new Object[]{new Long(1212)}, String.class); //返回一个String类型

Actor actor = (Actor) this.jdbcTemplate.queryForObject(

"select first_name, surname from t_actor where id = ?",

new Object[]{new Long(1212)},

new RowMapper() {

public Object mapRow(ResultSet rs, int rowNum) throws SQLException {

Actor actor = new Actor();

actor.setFirstName(rs.getString("first_name"));

actor.setSurname(rs.getString("surname"));

return actor;

}

}); //返回一个domain对象（JavaBean对象）

this.jdbcTemplate.update(

"insert into t_actor (first_name, surname) values (?, ?)",

new Object[] {"Leonor", "Watling"}); //插入操作

this.jdbcTemplate.update(

"update t_actor set weapon = ? where id = ?",

new Object[] {"Banjo", new Long(5276)}); //更新操作

this.jdbcTemplate.update(

"delete from actor where id = ?",

new Object[] {new Long.valueOf(actorId)}); //删除操作

this.jdbcTemplate.execute("create table mytable (id integer, name varchar(100))"); //执行一个DDL语句

13、JdbcDaoSupport支持类应用

package com.spring.dao;

import java.util.List;

import java.util.Map;

import org.springframework.jdbc.core.support.JdbcDaoSupport;

public class SpringJdbcDao extends JdbcDaoSupport {

public void getTbUsers() {

String sql = "select * from tb_user";

List<Map> list = getJdbcTemplate().queryForList(sql);

for (Map m : list) {

System.out.println(m.get("USER_ID")+"\t"+m.get("USER_NAME"));

}

配置文件代码

</bean>

14、批量SQL语句操作

@Repository

public class JdbcActorDao {

@Autowried

private JdbcTemplate jdbcTemplate;

public int[] batchUpdate(final List actors) {

int[] updateCounts = jdbcTemplate.batchUpdate(

"update t_actor set first_name = ?, last_name = ? where id = ?",

new BatchPreparedStatementSetter() {

public void setValues(PreparedStatement ps, int i) throws SQLException {

ps.setString(1, ((Actor)actors.get(i)).getFirstName());

ps.setString(2, ((Actor)actors.get(i)).getLastName());

ps.setLong(3, ((Actor)actors.get(i)).getId().longValue());

}

public int getBatchSize() {

return actors.size();

}

} );

return updateCounts;

}

15、Spring对Transaction的支持，这里只讲声明式事务管理配置

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

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

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

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/context

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

http://www.springframework.org/schema/tx

http://www.springframework.org/schema/tx/spring-tx-3.0.xsd

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

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

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

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"

destroy-method="close"

p:driverClassName="com.mysql.jdbc.Driver"

p:url="jdbc:mysql://localhost:3306/sampledb"

p:username="root"

p:password="1234" />

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"

p:dataSource-ref="dataSource" />

<bean id="transactionManager"

class="org.springframework.jdbc.datasource.DataSourceTransactionManager"

p:dataSource-ref="dataSource" />

<aop:config proxy-target-class="true">

<aop:pointcut id="serviceMethod"

expression=" execution(* com.gxaedu.service..*(..))" />

<aop:advisor pointcut-ref="serviceMethod" advice-ref="txAdvice" />

</aop:config>

<tx:advice id="txAdvice" transaction-manager="transactionManager">

<tx:attributes>

<tx:method name="add*" propagation="REQUIRED"/>

<tx:method name="update*" propagation="REQUIRED"/>

<tx:method name="*" read-only="true"/>

</tx:attributes>

</tx:advice>

</beans>

测试你Spring事务是否成功

l 注意配置事务是接口代理，则测试程序是接口

l 交叉测试，一个Service里面有两个以上的Dao对象。让第一个Dao对象SQL语句能够执行成功，但是第二个Dao对象SQL语句操作失败，看事务能不能管理Service中的方法，让数据全部回滚

何须低头

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录