无奇不有不置可否

Spring框架详细解析_完整学习Spring框架

一、Spring简述

1.1 了解Spring

Spring是一个开源的框架
Spring为了简化代码
Spring是一个IoC（DI）和AOP容器框架

1.2 Spring的特性

非侵入性：使用了Spring这种技术对原来的技术不造成任何影响，原来的技术可以和Spring一起用；
依赖注入：DI ，反转控制（IoC）的一种实现；
面向切面编程：Aspect Oriented Programming——AOP，是为了对OOP（面向对象编程）的补充；
容器：Spring是一个容器，因为它包含并且管理应用对象的生命周期；
组件化：把项目里的类，交给Spring管理。组件就是Spring所管理的对象，在Spring中可使用XML和Java注解组合这些对象。降低耦合度；
一站式：在IOC和AOP的基础上可以整合各种企业应用的开源框架和优秀的第三方类库（实际上Spring 自身也提供了表述层的SpringMVC和持久层的Spring JDBC）。

1.3 Spring的模块

Spring框架采用的是分层架构，它一系列的功能要素被分为20个模块。

二、搭建Spring运行环境

2.1 导入jar包

（1）Spring自身的jar包：

spring-beans-4.3.6.RELEASE.jar
spring-context-4.3.6.RELE2ASE.jar
spring-core-4.3.6.RELEASE.jar
spring-expression-4.3.6.RELEASE.jar

（2）导入记录日志的jar包 commons-logging-1.1.1.jar

2.2 配置xml文件

（1）如果使用eclipse，则创建xml文件，拷贝如下代码：
注意：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-4.3.xsd">
</beans>

（2）如果使用STS，则直接
① File->New->Spring Bean Configuration File
② 为文件取名字例如：applicationContext.xml

三、用Spring完成简单案例

3.1 创建Person类

package com.hkd.spring.mod;

public class Person {
	
	private Integer id;
	private String name;
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	@Override
	public String toString() {
		return "Person [id=" + id + ", name=" + name + "]";
	}
}

3.2 配置并完善applicationContext.xml文件


<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="personOne" class="com.hkd.spring.mod.Person">
      
      
   	  <property name="id" value="1001">property>
   	  <property name="name" value="小明">property>
   bean>
   
   <bean id="personTwo" class="com.hkd.spring.mod.Person">
   		<property name="id" value="1002">property>
   		<property name="name" value="小红">property>
   bean>
beans>

3.3 main函数里，创建Person对象并赋值

代码提要：

初始化容器
通过getBean()方法获取对象

package com.hkd.spring.mod;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestBySpring {
	public static void main(String[] args) {
		
		// 1.初始化容器
		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		// 2.通过getBean()方法获取对象（三种方法获取）
			// 2.1 第一种
		//Person person = (Person)ac.getBean("person");
			// 2.2 第二种【使用此方法获取对象时，要求Spring所管理的此类型的对象只能有一个】
		//Person person = ac.getBean(Person.class);
			// 2.3 第三种【一般用这个方式，同时指定id和name】
		Person person = ac.getBean("personOne", Person.class);
		System.out.println(person);
	}
}

3.4.完成并查看结果

四、IoC容器和Bean的配置

4.1 IoC和DI

4.1.1 IoC——反转控制

把原来自己对对象的控制权，交给了程序本身（Spring）来管理
我们不关心对象是怎样创建的，我们只关心我们用程序能调用到对象即可
对象的创建都交给Spring去做

4.1.2 DI——依赖注入

DI是IoC的另一种表述方式
IoC 就是一种反转控制的思想，而DI是对IoC的一种具体实现
依赖注入的过程就是给bean的属性赋值

4.1.3 IOC容器在Spring中的实现

在通过IoC容器读取Bean的实例之前，需要先将IOC容器本身实例化。
Spring提供了IoC容器的两种实现方式【使用后者】：
① BeanFactory：IoC容器的基本实现，是Spring内部的基础设施，是面向Spring本身的，不是提供给开发人员使用的。
② ApplicationContext：BeanFactory的子接口，提供了更多高级特性。面向Spring的使用者，几乎所有场合都使用ApplicationContext而不是底层的BeanFactory。

4.2 依赖注入的方式

4.2.1 set注入

在第三章Spring完成的简单案例中，applicationContext.xml文件里给Person类的id和name进行赋值的时候，用到了标签，这种就是set方式注入

   <bean id="personOne" class="com.hkd.spring.mod.Person">
      
      
	  
   	  <property name="id" value="1001">property>
   	  <property name="name" value="小明">property>
   bean>

原理：property的name属性的值不是看Person类中有没有id或者name这个属性，而是看有没有与id和name对应的set方法
举例：在Person类中，有setID()这个方法，所以可以set注入

4.2.2 构造方法注入

（1）这里重新写一个类Student，给它几个属性，并完成他的构造方法和toString方法（Java基础内容，如果不会的话要补课咯！）

package com.hkd.spring.di;

public class Student {
	
	private Integer id;
	private String name;
	private Integer age;
	private String sex;
	private double score;
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
		public double getScore() {
		return score;
	}
	public void setScore(double score) {
		this.score = score;
	}	
	
	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", age=" + age + ", sex=" + sex + ", score=" + score + "]";
	}
	
	
	public Student(Integer id, String name, Integer age, String sex) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
	
	public Student(Integer id, String name, double score, String sex) {
		super();
		this.id = id;
		this.name = name;
		this.score = score;
		this.sex = sex;
	}
	
	
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
}

（2）构造方式注入

第一种：用标签，提供里面的value值，会根据value值自动去实体类中找对应的构造方法，进行匹配
第二种：依然用标签，但除了value属性，我们还给他一个index和type属性，意思是第index个属性的类型是type，这样可以更加精确地匹配


<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="s2" class="com.hkd.spring.di.Student">
	  
		<constructor-arg value="10011">constructor-arg>
		<constructor-arg value="李四">constructor-arg>
		<constructor-arg value="23">constructor-arg>
		<constructor-arg value="男">constructor-arg>
	bean>
	
	<bean id="s3" class="com.hkd.spring.di.Student">
	  
		<constructor-arg value="10012">constructor-arg>
		<constructor-arg value="王五">constructor-arg>
	  	
		<constructor-arg value="90" index="2" type="double">constructor-arg>
		<constructor-arg value="男">constructor-arg>
	bean>
beans>

（3）编写main函数进行测试

package com.hkd.spring.di;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
	public static void main(String[] args) {
		ApplicationContext ac = new ClassPathXmlApplicationContext("beans-di.xml");
		// 获取student对象
		Student stu2 = ac.getBean("s2",Student.class);
		System.out.println(stu2);
		
		Student stu3 = ac.getBean("s3",Student.class);
		System.out.println(stu3);
	}
}

（4）最终结果
我们发现score被赋值了，说明构造方法注入成功！

4.3 p命名空间注入

Spring从2.5版本开始引入了一个新的p命名空间，可以通过元素属性的方式配置Bean的属性

首先，我们需要在beans命名空间处加上一句话

xmlns:p=“http://www.springframework.org/schema/p”

直接在bean标签的属性中，添加 p:属性的方式进行赋值


<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 id="s4" class="com.hkd.spring.di.Student" 
		p:id="10013" p:name="赵六" p:age="10" p:sex="男" 
		p:score="100.0">
	bean>
beans>

package com.hkd.spring.di;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
	public static void main(String[] args) {
		ApplicationContext ac = new ClassPathXmlApplicationContext("beans-di.xml");
		Student stu4 = ac.getBean("s4",Student.class);
		System.out.println(stu4);
	}
}

得出结果

4.4 其他注入方式

4.4.1 字面量

上面几个例子，我们赋值的时候，都是用value属性进行赋值的，value属性里面都是字符串，像这种的就叫做字面量注入。下面是字面量的定义：

可以使用字符串表示的值，可以通过value属性或value子节点的方式指定
基本数据类型及其封装类、String等类型都可以采取字面值注入的方式
若字面值中包含特殊字符，可以使用把字面值包裹起来

4.4.2 ref

如果value属性的值是一个引用类型，是一个类的话，它就不是字面量，就不能用value赋值了，这时候我们可以采用ref='bean的id'属性来进行注入

还使用上面的例子，假设学生类（Student）需要有一个教师类（Teacher）的属性

package com.hkd.spring.di;

public class Teacher {

	private Integer tid;
	private String tname;
	public Integer getTid() {
		return tid;
	}
	public void setTid(Integer tid) {
		this.tid = tid;
	}
	public String getTname() {
		return tname;
	}
	public void setTname(String tname) {
		this.tname = tname;
	}
	@Override
	public String toString() {
		return "Teacher [tid=" + tid + ", tname=" + tname + "]";
	}
}

需要给一个学生傻七配一个老师，编写学生类Student，有一个属性是Teacher类型

package com.hkd.spring.di;

public class Student {
	
	private Integer id;
	private String name;
	private Integer age;
	private String sex;
	private double score;
	private Teacher teacher;	//定义一个Teacher类型的属性
	
	public Teacher getTeacher() {
		return teacher;
	}
	public void setTeacher(Teacher teacher) {
		this.teacher = teacher;
	}
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public double getScore() {
		return score;
	}
	public void setScore(double score) {
		this.score = score;
	}	
	

	
	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", age=" + age + ", sex=" + sex + ", score=" + score
				+ ", teacher=" + teacher + "]";
	}
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
}

如果是一个Teacher对象的话，就要在xml文件里先把Teacher这个类给注入值，再用ref="bean的id"这种方式来注入bean


<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="s5" class="com.hkd.spring.di.Student">
		<property name="id" value="10014">property> 
		<property name="name" value="傻七">property>
		<property name="age" value="28">property>
		<property name="sex" value="男">property>
		
		<property name="teacher" ref="teacher">property>
	bean>
	
	<bean id="teacher" class="com.hkd.spring.di.Teacher">
		<property name="tid" value="001">property>
		<property name="tname" value="A老师">property>
	bean>
beans>

编写测试类，进行测试Teacher类是否注入进了Student类中

package com.hkd.spring.di;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
	public static void main(String[] args) {
		ApplicationContext ac = new ClassPathXmlApplicationContext("beans-di.xml");
		Student stu5 = ac.getBean("s5",Student.class);
		System.out.println(stu5);
	}
}

得到结果，注入成功

4.4.3 内部bean

还是上面的案例，在xml文件中，Teacher的bean在Student的bean的外部，这叫外部声明的bean，其实也可以声明在内部，叫内部bean
当bean实例仅仅给一个特定的属性使用时，可以将其声明为内部bean
内部bean声明直接包含在或元素里，不需要设置任何id或name属性
内部bean不能使用在任何其他地方，只能在自己的bean中使用

	
	<bean id="s6" class="com.hkd.spring.di.Student">
		<property name="id" value="10014">property> 
		<property name="name" value="崔八">property>
		<property name="age" value="38">property>
		<property name="sex" value="女">property>
		<property name="teacher">
		
			<bean class="com.hkd.spring.di.Teacher">
				<property name="tid" value="2222">property>
				<property name="tname" value="admin">property>
			bean>
		property>
	bean>

4.5 集合属性

4.5.1 List集合和数组

还是上面的例子，现在一个教师可以教多个班级，要输出一个教师所教的班级都有哪些，这时候就需要将班级用list集合的方式进行注入了
这些标签可以通过指定简单的常量值；通过指定对其他Bean的引用；通过指定内置bean定义；通过指定空元素；甚至可以内嵌其他集合
配置java.util.List类型的属性，需要指定标签，在标签里包含一些元素
配置java.util.Set需要使用标签，定义的方法与List一样
数组的定义和List一样，都使用元素，但数组还可以使用标签

（一）以字面量为值的list集合

在Teacher类中增加一个属性cls，并增加其set、get和toString方法

package com.hkd.spring.di;

import java.util.List;

public class Teacher {

	private Integer tid;
	private String tname;
	private List<String> cls;	//增加属性cls班级
	
	public List<String> getCls() {
		return cls;
	}
	public void setCls(List<String> cls) {
		this.cls = cls;
	}
	public Integer getTid() {
		return tid;
	}
	public void setTid(Integer tid) {
		this.tid = tid;
	}
	public String getTname() {
		return tname;
	}
	public void setTname(String tname) {
		this.tname = tname;
	}
	@Override
	public String toString() {
		return "Teacher [tid=" + tid + ", tname=" + tname + "]";
	}	
}

在xml文件中，对Teacher类进行实例化，这时候Teacher中的cls属性就必须赋值成一个list数组


<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 id="t1" class="com.hkd.spring.di.Teacher">
		<property name="tid" value="111">property>
		<property name="tname" value="张老师">property>
		<property name="cls">
			
			<list>
				<value>A班value>
				<value>B班value>
				<value>C班value>
			list>
		property>
	bean>
beans>

进行测试，看班级是否注入到了tid为111，tname为张老师的bean下了

package com.hkd.spring.di;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
	public static void main(String[] args) {
		ApplicationContext ac = new ClassPathXmlApplicationContext("beans-di.xml");
		Teacher t1 = ac.getBean("t1",Teacher.class);
		System.out.println(t1);
	}
}

得到结果，注入成功

（二）以bean的引用为值的list集合

现在要给一个tid为222、tname为李老师的老师分配学生，实质上就是给Teacher类注入一个Student类的List集合
编写xml里的bean，但是list的值是Student引用类型，如下

	
	<bean id="t2" class="com.hkd.spring.di.Teacher">
		<property name="tid" value="222">property>
		<property name="tname" value="李老师">property>
		<property name="students">
			
			<list>
				<ref bean="s1">ref>
				<ref bean="s2">ref>
				<ref bean="s3">ref>
			list>
		property>
	bean>

4.5.2 Map集合

Java.util.Map通过标签定义，标签里可以使用多个作为子标签。每个条目包含一个键和一个值
必须在标签里定义键
因为键和值的类型没有限制，所以可以自由地为它们指定、、或元素
可以将Map的键和值作为的属性定义：简单常量使用key和value来定义；bean引用通过key-ref和value-ref属性定义

<bean id="t3" class="com.hkd.spring.di.Teacher">
		<property name="tid" value="333">property>
		<property name="tname" value="王老师">property>
		<property name="bossMap">
			<map>
				<entry>
					<key>
						<value>10001value>
					key>
					<value>校长value>
				entry>
				
				<entry>
					<key>
						<value>10002value>
					key>
					<value>副校长value>
				entry>
			map>
		property>
	bean>

4.5.3 集合类型的bean

在4.5.1这一节中，我们发现标签在id为t1的bean的内部，这个里的内容只能在t1这个bean中使用。如果我们想在其他的bean中也能使用，则就需要将这个集合bean的配置拿到外面
配置集合类型的bean需要引入util名称空间

1. 首先我们需要在beans的命名空间处添加上util的命名空间

xmlns:util=“http://www.springframework.org/schema/util”
xsi:schemaLocation=“http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util-4.3.xsd”

2. 在xml文件里，使用标签，里面的集合可以是字面量，也可以是引用，这个list就写在了bean的外部，在bean中的property标签直接使用ref属性调用即可

	<bean id="t4" class="com.hkd.spring.di.Teacher">
		<property name="tid" value="444">property>
		<property name="tname" value="忽老师">property>
		<property name="students" ref="students">property>
	bean>
	<util:list id="students">
		<ref bean="s2"/>
		<ref bean="s3"/>
		<ref bean="s4"/>
	util:list>

在测试类中进行测试

package com.hkd.spring.di;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
	public static void main(String[] args) {
		ApplicationContext ac = new ClassPathXmlApplicationContext("beans-di.xml");
		Teacher t4 = ac.getBean("t4",Teacher.class);
		System.out.println(t4);
	}
}

得出结果，外部定义list集合注入成功

util标签还可以外部定义、、标签，以map为例随便写一个

	<util:map>
		<entry>
			<key>
				<value>1value>
			key>
			<value>张三value>
		entry>
	util:map>

4.6 FactoryBean

Spring中有两种类型的bean，一种是普通bean，另一种是工厂bean，即FactoryBean
工厂bean跟普通bean不同，其返回的对象不是指定类的一个实例，其返回的是该工厂bean的getObject方法所返回的对象
工厂bean必须实现org.springframework.beans.factory.FactoryBean接口

先创建一个Car类，里面有属性车的品牌和价格

package com.hkd.spring.factorybean;

public class Car {
	private String brand;
	private Double price;
	public String getBrand() {
		return brand;
	}
	public void setBrand(String brand) {
		this.brand = brand;
	}
	public Double getPrice() {
		return price;
	}
	public void setPrice(Double price) {
		this.price = price;
	}
	@Override
	public String toString() {
		return "Car [brand=" + brand + ", price=" + price + "]";
	}
}

创建一个MyFactory的类，里面实现FactoryBean接口，并重写三个方法getObject()将创建好的bean返回给IOC容器、getObjectType()返回bean的类型、isSingleton()创建的bean是否单例

package com.hkd.spring.factorybean;

import org.springframework.beans.factory.FactoryBean;

public class MyFactory implements FactoryBean<Car>{

	@Override
	public Car getObject() throws Exception {
		Car car = new Car();
		car.setBrand("奥迪");
		car.setPrice(200000.0);
		return car;
	}

	@Override
	public Class<?> getObjectType() {
		return Car.class;
	}

	@Override
	public boolean isSingleton() {
		return false;
	}
}

创建一个factory-bean.xml文件，注意class属性写的全类名是MyFactory的，因为MyFactory实现了FactoryBean接口，在工厂里进行创建对象



<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="factory" class="com.hkd.spring.factorybean.MyFactory">bean>
beans>

创建测试类进行测试，看得到的是不是Car的对象

package com.hkd.spring.factorybean;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
	public static void main(String[] args) {
		ApplicationContext ac = new ClassPathXmlApplicationContext("factory-bean.xml");
		Object object = ac.getBean("factory");
		System.out.println(object);
	}
}

得出结果，测试成功！

4.7 bean的作用域

在Spring中，可以在元素的scope属性里设置bean的作用域，以决定这个bean是单实例的还是多实例的
默认情况下，Spring只为每个在IoC容器里声明的bean创建唯一一个实例，整个IoC容器范围内都能共享该实例：所有后续的getBean()调用和bean引用都将返回这个唯一的bean实例。该作用域被称为singleton（单例），它是所有bean的默认作用域
当bean的作用域为singleton（单例）时，Spring会在IoC容器对象创建时就创建bean的对象实例
当bean的作用域为prototype时，IoC容器在获取bean的实例时创建bean的实例对象


<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="student" class="com.hkd.ioc.scope.Student" scope="singleton">
		<property name="sid" value="1001">property>
		<property name="sname" value="张三">property>
	bean>	
beans>

类别	说明
singleton	在SpringIOC容器里默认只存在一个bean实例，类型是单实例
prototype	每次调用getBean()时，都会返回一个新的实例
request	每次HTTP请求都会创建一个新的Bean，该作用域仅适用于WebApplicationContext环境
session	同一个HTTP Session共享一个Bean，不同的HTTP Session使用不同的Bean，该作用域仅适用于WebApplicationContext环境

4.8 bean的生命周期

4.8.1 bean的生命周期

Spring IoC容器可以管理bean的生命周期，Spring允许在bean生命周期内特定的时间点执行指定的任务
bean的生命周期进行管理的过程：

① 通过构造器或工厂方法创建bean实例
② 为bean的属性设置值和对其他bean的引用
③ 调用bean的初始化方法
④ bean可以使用了
⑤ 当容器关闭时，调用bean的销毁方法
举例演示：

首先创建一个类Person，给出几个属性、无参构造方法、toString方法，为了演示初始化和销毁，在这里创建初始化init方法和销毁destroy方法

package com.hkd.ioc.life;

public class Person {
	
	private Integer id;
	
	private String sex;
	
	private String name;

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		System.out.println("2.依赖注入");
		this.id = id;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "4.使用";
	}
	//bean创建实例的时候会调用无参构造
	public Person() {
		System.out.println("1.创建对象");
	}
	//创建初始化方法
	public void init() {
		System.out.println("3.初始化");
	}
	//创建销毁方法
	public void destroy() {
		System.out.println("5.销毁");
	}
}

创建life.xml文件，文件中创建bean实例
注意：如果想要调用到Person类中的init和destroy方法，需要在bean的属性中加入init-method='方法名'属性和destroy-method='方法名'属性，具体使用方法如下


<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.hkd.ioc.life.Person" init-method="init" destroy-method="destroy">
		<property name="id" value="1001">property>
		<property name="sex" value="男">property>
		<property name="name" value="张三">property>
	bean>	
beans>

创建测试类，进行测试

package com.hkd.ioc.life;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
	public static void main(String[] args) {
		ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("life.xml");
		Person person = ac.getBean("person",Person.class);
		System.out.println(person);
		//关闭bean
		ac.close();
	}
}

测试结果将bean实例创建的生命周期显示了出来

4.8.2 bean的后置处理器

bean后置处理器允许在调用初始化方法前后对bean进行额外的处理
bean后置处理器对IoC容器里的所有bean实例逐一处理，而非单一实例
bean后置处理器需要实现接口：
org.springframework.beans.factory.config.BeanPostProcessor
在初始化方法被调用前后，Spring将把每个bean实例分别传递给上述接口的以下两个方法：
- postProcessBeforeInitialization(Object, String)
- postProcessAfterInitialization(Object, String)
添加bean后置处理器后bean的生命周期

① 通过构造器或工厂方法创建bean实例

② 为bean的属性设置值和对其他bean的引用

③ 将bean实例传递给bean后置处理器的postProcessBeforeInitialization()方法【新增】

④ 调用bean的初始化方法

⑤ 将bean实例传递给bean后置处理器的postProcessAfterInitialization()方法【新增】

⑥ bean可以使用了

⑦ 当容器关闭时调用bean的销毁方法

4.9 自动装配

手动装配：以value或ref的方式明确指定属性值都是手动装配
自动装配：根据指定的装配规则，不需要明确指定，Spring自动将匹配的属性值注入bean中的property中
autowire属性：根据某种策略自动为非字面量属性赋值

autowire属性值	说明
default	由的上级标签的default-autowire属性值确定，上级为什么，这里的默认值就是什么
byName	通过属性名和Spring容器中bean的id进行比较，若一致则可直接赋值
byType	通过Spring容器中bean的类型，为兼容性的属性赋值

注意：

byType属性中，兼容性的属性是指可以通过子类的对象来为父类对象赋值，也可以通过实现类的对象来为接口赋值
byType属性中，要求Spring容器中只能有一个能为属性赋值的bean

缺点：当设置autowire属性的时候，会作用于该bean中所有的非字面量属性，有些不需要用到的属性也用到了，因此一般都不用这两种属性
举例说明

假设现在有一个员工Emp类，在这个员工类中有4个属性，eid员工的id、ename员工的name、car员工的车、dept员工的部门（里面的Car类型、Dept类型的变量这里不再展示）

package com.hkd.ioc.autowire;
	
public class Emp {
		
	private Integer eid;
		
	private String ename;
		
	private Car car;
		
	private Dept dept;
	
	public Integer getEid() {
		return eid;
	}
	
	public void setEid(Integer eid) {
		this.eid = eid;
	}
	
	public String getEname() {
		return ename;
	}
	
	public void setEname(String ename) {
		this.ename = ename;
	}
	
	public Car getCar() {
		return car;
	}
	
	public void setCar(Car car) {
		this.car = car;
	}
	
	public Dept getDept() {
		return dept;
	}
	
	public void setDept(Dept dept) {
		this.dept = dept;
	}
	
	@Override
	public String toString() {
		return "Emp [eid=" + eid + ", ename=" + ename + ", car=" + car + ", dept=" + dept + "]";
	}
}

编写auto.xml文件

一般的注入方法（之前已讲）


<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="emp" class="com.hkd.ioc.autowire.Emp" autowire="byName">
		<property name="eid" value="1001">property>
		<property name="ename" value="张三">property>
		<property name="car" ref="car">property>
		<property name="dept" ref="dept">property>
		
	bean>
	<bean id="car" class="com.hkd.ioc.autowire.Car">
		<property name="cid" value="666666">property>
		<property name="cname" value="奔驰">property>
	bean>
	<bean id="dept" class="com.hkd.ioc.autowire.Dept">
		<property name="did" value="1">property>
		<property name="dname" value="开发部">property>
	bean>
beans>

使用自动装配的byName属性进行装配


<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="emp" class="com.hkd.ioc.autowire.Emp" autowire="byName">
		<property name="eid" value="1001">property>
		<property name="ename" value="张三">property>
		
		
		
	bean>
	<bean id="car" class="com.hkd.ioc.autowire.Car">
		<property name="cid" value="666666">property>
		<property name="cname" value="奔驰">property>
	bean>
	<bean id="dept" class="com.hkd.ioc.autowire.Dept">
		<property name="did" value="1">property>
		<property name="dname" value="开发部">property>
	bean>
beans>

使用自动装配的byType进行装配


<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="emp" class="com.hkd.ioc.autowire.Emp" autowire="byType">
		<property name="eid" value="1001">property>
		<property name="ename" value="张三">property>
		
		

	bean>
	<bean id="car" class="com.hkd.ioc.autowire.Car">
		<property name="cid" value="666666">property>
		<property name="cname" value="奔驰">property>
	bean>
	<bean id="dept" class="com.hkd.ioc.autowire.Dept">
		<property name="did" value="1">property>
		<property name="dname" value="开发部">property>
	bean>
beans>

4.10 通过注解配置bean

4.10.1 常用的注解

@Component —— 标识一个受Spring IoC容器管理的组件（Bean），可以使用在任何层次，使用时只需将该注解标注在相应的类上即可
- @Component 是把最普通的类（不属于三层架构的类）实例化到spring容器中，相当于配置文件中的
- @Component(“userMod”)，括号里给的参数相当于配置的 id 属性
@Repository —— 标识一个受Spring IoC容器管理的持久化层组件（DAO层）
@Service —— 标识一个受Spring IoC容器管理的业务逻辑层组件（Service层）
@Controller —— 标识一个受Spring IoC容器管理的表述层控制器组件（控制层，处理请求和响应）

注意：
- 以上三个注解的功能完全相同，只是为了区分各个层而已，使代码更加清晰，在实际开发中，要在不同功能的类上加上相应的注解
- 组件的实质就是加上注解的类，也指Sping中管理的bean
@value("属性值") —— 对一般属性进行注入，直接写在属性的上方，可以不提供set方法
@Autowired —— 自动装配，在需要赋值的非字面量属性上，加上此注解，就可以在Spring容器中通过不同的方式匹配到相应的bean

注意：
- @Autowired 自动装配时默认byType（类型装配）的方式，此时要求Spring容器中只有一个能为其赋值
- 当默认的byType实现不了装配时，会自动切换到byName，此时要求Spring容器中有一个bean的id和属性名一致
- 若自动装配时，匹配到多个能够赋值的bean，可使用@Qualifier(value="beanId")指定使用的bean，具体使用方法如下： @Autowired和@Qualifier(value="beanId")可以一起作用于一个带形参的方法上，此时@Qualifier(value="beanId")所指定的bean作用于形参
@Resource(name="") —— 作用相当于@Autowired和@Qualifier的结合使用
1. @Resource(name="") 默认会根据指定的name属性去Spring容器中寻找与该名称匹配的类型
2. 例如：@Resource(name=“userDao”)，只有当找不到与名称匹配的Bean时才会按照类型来装配注入
3. 与@Autowired刚好相反，@Autowired是按照类型装配的，如果想按照名称进行装配还需要配合@Qualifier使用，而@Resource是按照名称装配的，名称找不到了才按照类型装配

4.10.2 通过注解方式配置bean的步骤

在需要被Spring管理的类上加上相应的注解
扫描组件 —— 类被注解标识后必须通过Spring进行扫描才能够起作用

4.10.3 扫描组件

导入jar包spring-aop-4.3.6.RELEASE.jar
在配置文件中的命名空间添加

xmlns:context=“http://www.springframework.org/schema/context”
xsi:schemaLocation=“http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.3.xsd”

使用标签，base-package的值为一个需要扫描的包

4.10.4 举例说明

我们重新创建一个包，名字是UserMod
实现三层架构中的控制层，并加上注解@controller

package com.hkd.ioc.userMod.controller;

import org.springframework.stereotype.Controller;

@Controller
public class UserController {

	public UserController() {
		System.out.println("UserController");
	}	
}

实现三层架构中的业务逻辑层，包含接口和实现类，并加上注解@service

package com.hkd.ioc.userMod.service;
//定义UserService接口
public interface UserService {
}

package com.hkd.ioc.userMod.service;

import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService{

	public UserServiceImpl() {
		System.out.println("UserServiceImpl");
	}
}

实现三层架构中的持久化层，包含接口和实现类，并加上注解@Repository

package com.hkd.ioc.userMod.service;
//定义UserDao接口
public interface UserDao {
}

package com.hkd.ioc.userMod.dao;

import org.springframework.stereotype.Repository;

@Repository
public class UserDaoImpl implements UserDao{

	public UserDaoImpl() {
		System.out.println("UserDaoImpl");
	}
}

编写user.xml配置文件，使用标签


<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" 
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
                        http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
                        http://www.springframework.org/schema/context 
                        http://www.springframework.org/schema/context/spring-context-4.3.xsd">
       
      <context:component-scan base-package="com.hkd.ioc.userMod">context:component-scan>              
                
beans>

编写测试类，看程序是否按照三层架构方式执行

package com.hkd.ioc.userMod;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

	public static void main(String[] args) {	
		ApplicationContext ac = new ClassPathXmlApplicationContext("user.xml");
	}
}

得出结论，基于Annotation注解的装配实现成功！

4.10.5 扫描组件的包含和排除

上两节我们介绍了标签，我们知道这个标签的属性base-package需要写的是一个包的名，意味着扫描这一个包，上一个例子里扫描了UserMod包，意味着UserMod包下的所有包都扫描了
但实际开发中，往往不需要扫描所有的包，就得一个一个写UserMod.Service,UserMod.Dao等等，比较麻烦

这里介绍了标签下的两个标签，可以在设定的包结构下再次通过注解和类型具体包含到某个或某几个类


<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" 
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
                        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
                        http://www.springframework.org/schema/context 
                        http://www.springframework.org/schema/context/spring-context-4.0.xsd">
       
      
      
       
       
      
      <context:component-scan base-package="com.hkd.ioc.userMod" use-default-filters="false">
      
      	
      	<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
      	
      	
      	<context:include-filter type="assignable" expression="com.hkd.ioc.UserMod.service.UserServiceImpl"/>
      	
      context:component-scan>              
                
      
      
      <context:component-scan base-package="com.hkd.ioc.UserMod">
      
      	
      	<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Repository"/>
		
		
		<context:exclude-filter type="assignable" expression="com.hkd.ioc.UserMod.service.UserServiceImpl"/>
		
      context:component-scan>
      
     
beans>

五、Spring AOP

5.1 AOP面向切面编程

AOP（Aspect-Oriented Programming，面向切面编程）是对传统OOP（Object-Oriented Programming，面向对象编程）的一种补充

面向对象是纵向继承机制
面向切面是横向抽取机制

AOP编程操作的主要对象是切面(aspect)，存储公共功能的类就叫做切面
切面的作用：模块化横切关注点（公共功能）

在用AOP编程时，有些方法需要定义一些公共功能，这些公共功能是针对不同类需要做相同的事情而编写的，这些方法叫做横切关注点，把横切关注点抽取出来，放到一个类里，这样的类我们通常称之为切面

上图便于我们理解AOP：四个方法中都有验证参数、前置日志和后置日志三个功能，这些公共功能叫做横切关注点，把这些横切关注点抽取出来放到一个类里，这个类就是切面，最后通过AOP实现三个功能
AOP的好处：
- 每个事物逻辑位于一个位置，代码不分散，便于维护和升级
- 业务模块更简洁，只包含核心业务代码

5.2 AOP相关术语

5.2.1 横切关注点

从每个方法中抽取出来的同一类非核心业务

5.2.2 切面（Aspect）

将横切关注点封装成一个类，这个类就是切面

5.2.3 通知（Advice）

横切关注点在切面里的叫法，二者实际是一个东西，在不同位置叫法不同

5.2.4 目标对象（Target Object）

被通知的对象，也就是抽取出的代码所作用到的对象

5.2.5 代理（Proxy）

将通知应用到目标对象之后，被动态创建的对象

5.2.6 连接点（Joinpoint）

功能执行过程中的各个位置，一般只操作四个位置：方法调用前、方法调用后、当抛出异常和finally位置

5.2.7 切入点（Pointcut）

定位连接点的方式。每个类的方法中都包含多个连接点，AOP可以通过切入点定位到特定的连接点
切点通过org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条件
切入点指的是类和方法名

5.3 动态代理

5.3.1 动态代理的原理

使用一个代理将原本对象包装起来，然后用该代理对象“取代”原始对象
任何对原始对象的调用都要通过代理
代理对象决定是否以及何时将方法调用转到原始对象上

5.3.2 动态代理的分类

基于接口实现动态代理： JDK动态代理
基于继承实现动态代理： CGLIB、Javassist动态代理

5.3.3 JDK动态代理

JDK动态代理通过java.lang.reflect.Proxy来实现
JDK动态代理必须有一个业务接口类

举例说明：

首先创建一个MathI接口，里面提供了加减乘除的四个方法

package com.hkd.proxy;
public interface MathI {
	//加
	public int plus(int i, int j);
	//减
	public int sub(int i, int j);
	//乘
	public int mul(int i, int j);
	//除
	public int div(int i, int j);	
}

创建接口的实现类MathImpl，并添加方法的具体实现

package com.hkd.proxy;
public class MathImpl implements MathI{

	@Override
	public int plus(int i, int j) {
		int result = i + j;
		return result;
	}

	@Override
	public int sub(int i, int j) {
		int result = i - j;
		return result;
	}

	@Override
	public int mul(int i, int j) {
		int result = i * j;
		return result;
	}

	@Override
	public int div(int i, int j) {
		int result = i / j;
		return result;
	}
}

创建日志类MyLogger，现在想在执行加减乘除方法之前和之后，有一个记录日志的操作，分别记录两个数是多少，和结果是多少

package com.hkd.proxy;

public class MyLogger {
	//方法执行前的记录
	public static void before(String methodName, String args) {
		System.out.println("method："+methodName+"，args："+args);
	}
	//方法执行后的记录
	public static void after(String methodName, Object result) {
		System.out.println("method："+methodName+",args："+result);
	}
}

创建代理类，注意看步骤

package com.hkd.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class ProxyUtil {
	
	//声明目标类接口
	private MathImpl mathImpl;
	
	
	public ProxyUtil(MathImpl mathImpl) {
		super();
		this.mathImpl = mathImpl;
	}


	//创建代理方法
	public Object getProxy() {
		
		//1. 获取当前类的类加载器，用来加载代理对象所属类
		ClassLoader loader = this.getClass().getClassLoader();
		
		//2. 获取目标对象实现的所有接口的class，代理类会和目标类实现相同的接口，最终通过代理对象实现功能
		Class[] interfaces = mathImpl.getClass().getInterfaces();
		
		//3. 使用代理类，进行增强，返回的是代理后的对象。Proxy.newProxyInstance(类加载器，接口，匿名内部类)
		return Proxy.newProxyInstance(loader, interfaces, new InvocationHandler() {
			
			//所有动态代理的方法调用，都会交由invoke()方法去处理
			//proxy：被代理后的对象
			//method：将要被执行的方法信息
			//args：执行方法时需要的参数
			
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				try {
					//通过代理对象实现功能，这时候就可以在实现功能前后加入一些其他的操作，比如下面的before和after方法
					MyLogger.before(method.getName(), Arrays.toString(args));
					//动态代理对象实现功能
					Object result = method.invoke(mathImpl, args);
					MyLogger.after(method.getName(), result);
					return result;
				} catch (Exception e) {
					MyLogger.throwing();
					e.printStackTrace();
				}
				return null;
			}	
		});
	}
}

创建测试类，进行测试

package com.hkd.proxy;

public class Test {
	public static void main(String[] args) {
		ProxyUtil proxy = new ProxyUtil(new MathImpl());
		MathI math = (MathI)proxy.getProxy();
		//执行plus方法
		int i = math.plus(1, 1);
	}
}

得出结果，成功记录了加数和结果

5.3.4 CGLIB动态代理

JDK动态代理虽然方便，但是代理对象必须实现一个或多个接口
如果没有接口，可以使用CGLIB动态代理

5.4 AspectJ开发

5.4.1 什么是AspectJ

AspectJ是Java社区里最完整最流行的AOP框架，它提供了强大的AOP功能
在Spring2.0以上版本中，可以使用基于AspectJ注解或基于XML配置的AOP

5.4.2 AspectJ环境搭建

1. 导入jar包

在Spring基础5个包的基础上导入以下jar包

com.springsource.org.aopalliance-1.0.0.jar
com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
spring-aop-4.3.6.RELEASE.jar
spring-aspects-4.3.6.RELEASE.jar
如果不适用接口，则使用cglib动态代理，导入com.springsource.net.sf.cglib-2.2.0.jar

2. 添加命名空间

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

5.4.3 切入点表达式

1. 格式：

execution( [权限修饰符] [返回值类型] [简单类名/全类名] [方法名] ([参数列表]) )

2. 作用：

通过表达式的方式定位一个或多个具体的连接点

3. 举例：

execution(public void com.hkd.study.aop.plus(int, int))
意思是：访问修饰符为public，返回值是void类型，aop接口声明的plus方法，并且方法需要两个int类型的参数

execution( * com.hkd.study.aop.*.*(..))
a. 第一个*表示任意修饰符及任意返回值；
b. 第二个*表示类名，使用*代表所有的类；
c. 第三个*表示方法名，使用*代表所有方法；最后的(..)表示任意数量、类型的参数
d. 注意第一个*与包名直接有一个空格

4. 注意：

在AspectJ中，切入点表达式可以通过 “&&”、"||"、"!"等操作符结合起来，例如：

execution (* *.add(int,..)) || execution(* *.sub(int,..))
表示任意类中第一个参数为int类型的add方法或sub方法

!execution (* *.add(int,..))
表示匹配不是任意类中第一个参数为int类型的add方法

5.4.4 连接点

1. 连接点

就一个具体的连接点而言，我们可能会关心这个连接点的一些具体信息例如：当前连接点所在方法的方法名、当前传入的参数值等等
这些信息都封装在JoinPoint接口的实例对象中

2. 常用的方法
joinpoint.getArgs() —— 获取实际参数数组
joinpoint.getSignature().getName() —— 获取方法名

5.4.5 AspectJ注解

注解名称	描述
@Aspect	用于定义一个切面
@PointCut	用于定义一个切入点表达式。使用时还需要定义一个包含名字和任意参数的方法签名来表示切入点表达式。实际上这个方法签名就是一个返回值为void且方法体为空的普通方法

5.4.6 通知

通知名称	通知标识	描述
前置通知	@Before	作用于方法执行之前需要指定value属性，该属性值用于指定一个切入点表达式
后置通知	@After	作用于方法的finally语句块，后置通知是在连接点完成之后执行的，即不管有没有异常，都会执行
返回通知	@AfterReturning	作用于方法执行之后，可通过returning设置接受方法返回值的变量名，要想在方法中使用，必须要方法的形参中设置和变量名相同的参数名的参数
异常通知	@AfterThrowing	作用于方法抛出异常时，可通过throwing设置接收方法返回的异常信息在参数列表中，通过具体的异常类型，来对指定的异常信息进行操作
环绕通知	@Around	能够全面地控制连接点，甚至可以控制是否执行连接点。连接点的参数类型必须是ProceedingJoinPoint，需要明确调用ProceedingJoinPoint的proceed()方法来执行被代理的方法

以上通知的演示在5.4.6节的案例里

5.4.7 基于注解的声明式AspectJ

1. 仍然以加减乘除为例，演示各类通知，首先编写MathI接口

package com.hkd.AspectJ;

public interface MathI {
	
	public int plus(int i, int j);
	
	public int sub(int i, int j);
	
	public int mul(int i, int j);
	
	public int div(int i, int j);
	
}

2. 编写接口的实现类，注意注解的运用

package com.hkd.AspectJ;

import org.springframework.stereotype.Component;

@Component()
public class MathImpl implements MathI{

	@Override
	public int plus(int i, int j) {
		int result = i + j;
		return result;
	}

	@Override
	public int sub(int i, int j) {
		int result = i - j;
		return result;
	}

	@Override
	public int mul(int i, int j) {
		int result = i * j;
		return result;
	}

	@Override
	public int div(int i, int j) {
		int result = i / j;
		return result;
	}
}

3. 编写日志类，解析各种通知的写法

package com.hkd.AspectJ;

import java.util.Arrays;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect	//标注当前类为切面
@Component
public class MyloggerAspect {
	
	/**
	 * @Before：将方法指定为前置通知
	 * 必须设置value，其值为切入点表达式
	 * 前置通知，作用于方法执行之前
	 */
	@Before(value = "execution(* com.hkd.AspectJ.*.*(..))")
	public void beforeMethod(JoinPoint joinPoint) {
		Object[] args = joinPoint.getArgs();	//获取方法的参数
		String methodName = joinPoint.getSignature().getName();	//获取方法名
		System.out.println("method:"+methodName+",arguments:"+Arrays.toString(args));
	}
	
	/**
	 * @After：将方法标注为后置通知
	 * 作用于方法的finally语句块，即不管有没有异常都会执行
	 */
	@After(value = "execution(* com.hkd.AspectJ.*.*(..))")
	public void afterMethod() {
		System.out.println("后置通知");
	}
	
	/**
	 * @AfterReturning：将方法标注为返回通知
	 * 作用于方法执行之后
	 * 可通过returning设置接受方法返回值的变量名
	 * 要想在方法中使用，必须要方法的形参中设置和变量名相同的参数名的参数
	 */
	@AfterReturning(value = "execution(* com.hkd.AspectJ.*.*(..))",returning = "result")
	public void afterReturning(JoinPoint joinPoint, Object result) {
		String methodName = joinPoint.getSignature().getName();
		System.out.println("method:"+methodName+",result:"+result);
	}
	
	/**
	 * @AfterThrowing：将方法标注为异常通知（例外通知）
	 * 作用于方法抛出异常时
	 * 可通过throwing设置接收方法返回的异常信息
	 * 在参数列表中，通过具体的异常类型，来对指定的异常信息进行操作
	 */
	@AfterThrowing(value = "execution(* com.hkd.AspectJ.*.*(..))",throwing = "ex")
	public void afterThrowingMethod(Exception ex) {
		System.out.println("有异常了:" + ex);
	}
	
	@Around(value="execution(* com.hkd.AspectJ.*.*(..))")
	public Object arountMethod(ProceedingJoinPoint joinPoint) {
		Object result = null;
		try {
			//前置通知
			System.out.println("前置通知");
			result = joinPoint.proceed();  //执行方法
			//返回通知
			System.out.println("返回通知");
			return result;
		} catch (Throwable e) {
			//异常通知
			System.out.println("异常通知");
			e.printStackTrace();
		} finally {
			//后置通知
			System.out.println("后置通知");
		}
		return -1;
	}
}

4. 编xml文件


<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"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/bean http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
                        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
                        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
	
	<context:component-scan base-package="com.hkd.AspectJ">context:component-scan>
	
	<aop:aspectj-autoproxy />

beans>

5. 编写测试类，进行测试

package com.hkd.AspectJ;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

	public static void main(String[] args) {
		ApplicationContext ac = new ClassPathXmlApplicationContext("aop.xml");
		MathI math = ac.getBean("mathImpl", MathI.class);
		int i = math.div(2, 1);
		System.out.println(i);
	}
}

6. 得出结果，各种通知实现成功

5.4.8 重用切入点

在编写AspectJ切面时，可以直接在通知注解中书写切入点表达式，但同一个切点表达式可能会在多个通知中重复出现
在AspectJ切面中，可以通过@Pointcut注解将一个切入点声明成简单的方法
切入点的方法体通常是空的，因为将切入点定义与应用程序逻辑混在一起是不合理的
切入点方法的访问控制符同时也控制着这个切入点的可见性，如果切入点要在多个切面中共用，最好将它们集中在一个公共的类中。在这种情况下，它们必须被声明为public，在引入这个切入点时，必须将类名也包括在内。如果类没有与这个切面放在同一个包中，还必须包含包名

package com.hkd.AspectJ;

import java.util.Arrays;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect	//标注当前类为切面
@Component
public class MyloggerAspect {
	
	@Pointcut(value = "execution(* com.hkd.AspectJ.*.*(..))")
	public void test() {}
	
	@Before(value = "test()")	//重用切入点
	public void beforeMethod(JoinPoint joinPoint) {
		Object[] args = joinPoint.getArgs();	//获取方法的参数
		String methodName = joinPoint.getSignature().getName();	//获取方法名
		System.out.println("method:"+methodName+",arguments:"+Arrays.toString(args));
	}
}

5.4.9 切面的优先级

在同一个连接点上应用不止一个切面时，除非明确指定，否则它们的优先级是不确定的
切面的优先级以通过实现Ordered接口或利用@Order注解指定
实现Ordered接口，getOrder()方法的返回值越小，优先级越高
若使用@Order注解，值越小优先级越高，@Order(1)比@Order(2)的优先级高，默认值为int的最大值

5.4.10 基于xml的声明式AspectJ

正常情况下，基于注解的声明要优先于基于XML的声明
通过AspectJ注解，切面可以与AspectJ兼容，而基于XML的配置则是Spring专有的

1. 编写接口和实体类

package com.hkd.AspectJ_xml;
public interface MathI {	
	public int plus(int i, int j);	
	public int sub(int i, int j);	
	public int mul(int i, int j);
	public int div(int i, int j);	
}

package com.hkd.AspectJ_xml;
import org.springframework.stereotype.Component;
@Component()
public class MathImpl implements MathI{
	@Override
	public int plus(int i, int j) {
		int result = i + j;
		return result;
	}
	@Override
	public int sub(int i, int j) {
		int result = i - j;
		return result;
	}
	@Override
	public int mul(int i, int j) {
		int result = i * j;
		return result;
	}
	@Override
	public int div(int i, int j) {
		int result = i / j;
		return result;
	}
}

2. 编写切面类

package com.hkd.AspectJ_xml;

import org.springframework.stereotype.Component;

@Component
public class MyLogger {
	
	public void Before() {
		System.out.println("前置通知");
	}
	
	public void AfterReturning() {
		System.out.println("后置通知");
	}
	
	public void Around() {
		System.out.println("环绕通知");
	}
	
	public void AfterThrowing() {
		System.out.println("异常通知");
	}
	
	public void After() {
		System.out.println("最终通知");
	}
}

3. 配置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:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
                        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
                        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
	
	<context:component-scan base-package="com.hkd.AspectJ_xml"></context:component-scan>
	
	<aop:config>
		<!-- 1. 配置切面 -->		
		<aop:aspect ref="myLogger">
			<!-- 2. 配置切入点 -->
			<aop:pointcut expression="execution(* com.hkd.AspectJ_xml.*.*(..))" id="cut"/>
			<!-- 3. 配置通知 -->
				<!-- 配置前置通知 -->
			<aop:before method="Before" pointcut-ref="cut"/>
				<!-- 配置后置通知 -->
			<aop:after-returning method="AfterReturning" pointcut-ref="cut" returning="returnVal"/>
				<!-- 配置环绕通知 -->
			<aop:around method="Around" pointcut-ref="cut"/>
				<!-- 配置异常通知 -->
			<aop:after-throwing method="AfterThrowing" pointcut-ref="cut" throwing="e"/>
				<!-- 配置最终通知 -->
			<aop:after method="After" pointcut-ref="cut"/>
		</aop:aspect>
	</aop:config>
</beans>

4. 编写测试类

package com.hkd.AspectJ_xml;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
	public static void main(String[] args) {
		ApplicationContext ac = new ClassPathXmlApplicationContext("AspectJ_xml.xml");
		MathI math = ac.getBean("mathImpl",MathI.class);
		int i = math.plus(1, 3);
		System.out.println(i);
	}
}

六、JdbcTemplate

6.1 JdbcTemplate概述

为了使JDBC更加易于使用，减少代码量，Spring在JDBC API上定义了一个抽象层，以此建立一个JDBC存取框架
作为Spring JDBC框架的核心，JDBC模板的设计目的是为不同类型的JDBC操作提供模板方法。通过这种方式，可以在尽可能保留灵活性的情况下，将数据库存取的工作量降到最低
可以将Spring的JdbcTemplate看作是一个小型的轻量级持久化层框架

6.2 搭建JdbcTemplate环境

6.2.1 导入jar包

在Spring基础5个包的基础上导入以下jar包：

spring-jdbc-4.3.6.RELEASE.jar
spring-orm-4.3.6.RELEASE.jar
spring-tx-4.3.6.RELEASE.jar

还需要导入数据库连接相关包：

mysql-connector-java-5.1.37-bin.jar
使用druid连接池：druid-1.1.9.jar
使用c3p0连接池：c3p0-0.9.5.5.jar，mchange-commons-java-0.2.19.jar

6.2.2 创建属性文件db.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm
jdbc.username=root
jdbc.password=123

6.2.3 创建连接池

如果使用的是druid连接池，这样创建连接池


<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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
                        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
	
	

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

	
	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
		<property name="driverClassName" value="${jdbc.driver}">property>
		<property name="url" value="${jdbc.url}">property>
		<property name="username" value="${jdbc.username}">property>
		<property name="password" value="${jdbc.password}">property>
	bean>
	
	
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource">property>
	bean>
beans>

如果使用的是c3p0连接池，这样创建连接池


<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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
                        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
	
	

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

	
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${jdbc.driver}">property>
		<property name="jdbcUrl" value="${jdbc.url}">property>
		<property name="user" value="${jdbc.username}">property>
		<property name="password" value="${jdbc.password}">property>
	bean>
	
	
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource">property>
	bean>
beans>

6.3 update()增删改

update()方法可以完成增删改操作，其返回值是int类型，返回受影响的行数

创建一个实体类Emp，其中有属性，并且在MySQL数据库中创建相应的表

package com.hkd.jdbctemplate;
public class Emp {
private Integer eid;
	private String ename;	
	private Integer age;	
	private String sex;
	public Integer getEid() {
		return eid;
	}
	public void setEid(Integer eid) {
		this.eid = eid;
	}
	public String getEname() {
		return ename;
	}
	public void setEname(String ename) {
		this.ename = ename;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	@Override
	public String toString() {
		return "Emp [eid=" + eid + ", ename=" + ename + ", age=" + age + ", sex=" + sex + "]";
	}	
}

使用c3p0数据库连接池进行数据库连接，详见6.2的步骤

使用Junit测试，进行update()的测试

package com.hkd.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;

public class TestJdbcTemplate {
	ApplicationContext ac = new ClassPathXmlApplicationContext("jdbc_c3p0.xml");
	JdbcTemplate jdbcTemplate = ac.getBean("jdbcTemplate",JdbcTemplate.class);
	
	@Test
	public void testUpdate() {
		//增删改函数（这里以增加为例）
		String sql = "insert into emp values(null,?,?,?)";
		//单条数据的增删改
		jdbcTemplate.update(sql, "Jack", 24, "Women");
	}
}

完成测试，得到结果，Jack已增加

6.4 batchUpdate(String, List)批量增删改

batchUpdate(String, List)执行批量增删改操作
第一个参数String是提供的sql语句
第二个参数的Object[]封装了sql语句每一次执行时所需要的参数，List集合封装了sql语句多次执行时的所有参数

仍然使用6.3节的案例，Emp实体类、数据库表和数据库连接池
批量增删改的方法

	@Test
	public void testBatchUpdate() {
		// 批量执行增删改的方法（这里以批量增加为例）
		String sql = "insert into emp values(null,?,?,?)";
		List<Object[]> list = new ArrayList<>();
		list.add(new Object[] {"aa",11,"Woman"});
		list.add(new Object[] {"bb",22,"Woman"});
		list.add(new Object[] {"cc",33,"Woman"});
		jdbcTemplate.batchUpdate(sql, list);
	}

得到结果，已增加成功

6.5 queryForObject()

6.5.1 查询一条数据，返回一个对象

queryForObject(String, RowMapper\, Object...) 用来获取单条数据，返回一个对象
第一个参数String是sql语句
第二个参数RowMapper是返回一个Object类型的对象
第三个参数是sql语句中的参数

@Test
public void testQueryForObjectReturnSingleObject() {
	//queryForObject(sql, rowMapper, args) 用来获取单条数据，返回一个对象
	String sql = "select eid,ename,age,sex from emp where eid = ?";
	//将列名（字段名或字段名的别名）与属性名进行映射
	RowMapper<Emp> rowMapper = new BeanPropertyRowMapper<>(Emp.class);	
	Emp emp = jdbcTemplate.queryForObject(sql, rowMapper, 1);
	System.out.println(emp);
}

6.5.2 查询单个值，返回这个值

queryForObject(String, Class, Object...)
第一个参数是String类型的sql语句
第二个参数是最后返回的是什么类型的这里就写什么类型
第三个参数是参数

@Test
public void testQueryForObjectReturnSingleValue() {
	//jdbcTemplate.queryForObject(sql, requiredType) 用来获取单个的值
	String sql = "select count(eid) from emp";
	Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
	System.out.println(count);
}

6.6 query()查询

查询多条数据返回多个对象

@Test
public void testQuery() {
	String sql = "select eid,ename,age,sex from emp";
	RowMapper<Emp> rowMapper = new BeanPropertyRowMapper<>(Emp.class);
	List<Emp> list = jdbcTemplate.query(sql, rowMapper);
	for(Emp emp : list) {
		System.out.println(emp);
	}
}

6.7 JdbcTemplate中的DAO模式

创建Emp接口类和EmpImpl接口实现类，注意接口实现类里@Autowire自动装配

package com.hkd.jdbc.dao;

import com.hkd.jdbctemplate.Emp;

public interface EmpDao {
	public int insertEmp(Emp emp);
}

package com.hkd.jdbc.dao;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import com.hkd.jdbctemplate.Emp;

@Repository
public class EmpDaoImpl implements EmpDao{

	@Autowired
	private JdbcTemplate jdbcTemplate;
	
	@Override
	public int insertEmp(Emp emp) {
		String sql = "insert into emp values(null,?,?,?)";
		Object[] obj = new Object[] {
				emp.getEname(),emp.getAge(),emp.getSex()
		};
		return jdbcTemplate.update(sql, obj);
	}
}

在jdbc_dao.xml文件中配置


<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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
                        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
	
	
	<context:component-scan base-package="com.hkd.jdbc.dao">context:component-scan>
	
	
	<context:property-placeholder location="classpath:db.properties" />

	
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${jdbc.driver}">property>
		<property name="jdbcUrl" value="${jdbc.url}">property>
		<property name="user" value="${jdbc.username}">property>
		<property name="password" value="${jdbc.password}">property>
	bean>
	
	
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource">property>
	bean>
beans>

在测试类里进行dao模式的测试

package com.hkd.jdbc.dao;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.hkd.jdbctemplate.Emp;

public class test {

	public static void main(String[] args) {
		ApplicationContext ac = new ClassPathXmlApplicationContext("jdbc_dao.xml");
		EmpDao empDao = ac.getBean("empDaoImpl",EmpDao.class);
		Emp emp = new Emp();
		emp.setEid(8);
		emp.setEname("zhangsan");
		emp.setAge(80);
		emp.setSex("Man");
		int num = empDao.insertEmp(emp);
		if(num>0)
			System.out.println("插入"+num+"条数据成功");
		else
			System.out.println("插入数据失败");
	}
}

得出结果，dao模式连接数据库成功

七、Spring事务管理

7.1 事务概述

事务就是一组由于逻辑上紧密关联而合并成一个整体（工作单元）的多个数据库操作，这些操作要么都执行，要么都不执行
事务的四个关键属性

属性	属性解释
原子性(atomicity)	“原子”的本意是“不可再分”，事务的原子性表现为一个事务中涉及到的多个操作在逻辑上缺一不可。事务的原子性要求事务中的所有操作要么都执行，要么都不执行
一致性(consistency)	“一致”指的是数据的一致，具体是指：所有数据都处于满足业务规则的一致性状态。一致性原则要求：一个事务中不管涉及到多少个操作，都必须保证事务执行之前数据是正确的，事务执行之后数据仍然是正确的。如果一个事务在执行的过程中，其中某一个或某几个操作失败了，则必须将其他所有操作撤销，将数据恢复到事务执行之前的状态，这就是回滚
隔离性(isolation)	在应用程序实际运行过程中，事务往往是并发执行的，所以很有可能有许多事务同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏。隔离性原则要求多个事务在并发执行过程中不会互相干扰
持久性(durability)	持久性原则要求事务执行完成后，对数据的修改永久的保存下来，不会因各种系统错误或其他意外情况而受到影响。通常情况下，事务对数据的修改应该被写入到持久化存储器中

7.2 事务环境搭建

1. 在原有的5个基本包的基础上导入以下jar包

AspectJ和aop相关包：
com.springsource.org.aopalliance-1.0.0.jar
com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
spring-aop-4.3.6.RELEASE.jar
事务相关包：
spring-tx-4.3.6.RELEASE.jar

2. 添加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

3. 配置文件需要配置事务管理器


	<bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		
		<property name="dataSource" ref="dataSource">property>
	bean>

7.3 事务的传播行为propagation

7.3.1 什么是事务的传播行为和属性

A方法和B方法都有事务，当A在调用B的时候，会将A中的事务传播给B方法，B方法对于事务的处理方式就是事务的传播行为

属性名称	属性值	属性解释
PROPAGATION_REQUIRED	REQUIRED	如果有事务在运行，当前的方法就在这个事务中运行，否则启动新事务，再执行方法
PROPAGATION_REQUIRES_NEW	REQUIRES_NEW	如果方法已在事务环境中，则停止该事务，使用自己的事务；如果方法不在事务环境中，则自动启动一个新事务后再执行方法
PROPAGATION_SUPPORTS	SUPPORTS	如果当前方法处于事务环境中，则使用该事务，否则不使用事务
PROPAGATION_NOT_SUPPORTED	NOT_SUPPORTED	当前方法不应该运行在事务中，如果有则将它挂起
PROPAGATION_MANDATORY	MANDATORY	当前方法必须运行在事务内部，如果没有运行的事务，就抛出异常
PROPAGATION_NEVER	NEVER	当前方法不应该运行在事务中，如果有运行的事务，就抛出异常
PROPAGATION_NESTED	NESTED	即使当前方法处于事务中，依然会启动一个新事务，并且方法在嵌套的事务中执行；即使当前执行的方法不在事务中，也会启动一个新事务，然后执行该方法

7.3.2 事务的传播行为的用法

1. 注解方式

直接在要处理事务的类或者方法前，加上注解，注解中括号里添加属性propagation，如下

@Transactional(propagation = Propagation.REQUIRES_NEW)

2. 配置方式

7.4 事务的隔离级别

7.4.1 数据库事务并发问题

1. 脏读：

① A将某条记录的age值从20修改为30
② B读取了A更新后的值：30
③ 现在A回滚了，age值恢复到了20
④ B读取到的30就是一个无效的值

2. 不可重复读

① A读取了age值为20
② B将age值修改为30
③ A再次读取age值成了30，和第一次读取不一致了

3. 幻读

① A读取了student表中的一部分数据
② B向student表中插入了新的行
③ A再读取student表时，就多出了一些行

7.4.2 隔离级别

数据库系统必须具有隔离并发运行各个事务的能力，使它们不会相互影响，避免各种并发问题。一个事务与其他事务隔离的程度称为隔离级别

读未提交：READ UNCOMMITTED
允许A读取B未提交的修改
读已提交：READ COMMITTED
要求A只能读取B已提交的修改
可重复读：REPEATABLE READ
确保A可以多次从一个字段中读取到相同的值，即A执行期间禁止其它事务对这个字段进行更新
串行化：SERIALIZABLE
确保A可以多次从一个表中读取到相同的行，在A执行期间，禁止其它事务对这个表进行添加、更新、删除操作。可以避免任何并发问题，但性能十分低下

能力	脏读	不可重复读	幻读
READ UNCOMMITTED	√	√	√
READ COMMITTED	×	√	√
REPEATABLE READ	×	×	√
SERIALIZABLE	×	×	×

7.4.3 事务隔离级别的写法

1. 注解方式

直接在@Transactional的isolation属性中设置隔离级别

@Transactional(isolation = Isolation.DEFAULT)

2. 配置方式

7.5 事务的超时和只读属性

timeout：在事务强制回滚前，最多可以执行（等待）的时间
readOnly：指定当前事务中的一系列操作是否为只读；
1. 如果设置为只读，不管事务中有没有写的操作，MySQL都会在请求访问数据的时候，不加锁，提高性能；
2. 如果有写的操作，建议一定不能设置只读

7.6 声明式事务管理写法

7.6.1 基于注解的声明式事务管理

1. 开启事务注解


<tx:annotation-driven transaction-manager="dataSourceTransactionManager"/>

2. 在需要使用事务的bean类或者bean类方法上使用注解@Transactional

如果在方法上，则对这个方法有效；如果在类上，则对类中的所有方法有效
其中的一些属性，已经在之前的讲解中展示如何书写

7.6.2 基于xml的声明式事务管理


	<bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		
		<property name="dataSource" ref="dataSource">property>
	bean>
	

	<aop:config>
		<aop:pointcut 
			expression="execution(* com.atguigu.tx.component.service.BookShopServiceImpl.purchase(..))" 
			id="txPointCut"/>
		
		<aop:advisor advice-ref="myTx" pointcut-ref="txPointCut"/>
	aop:config>
	

	<tx:advice id="myTx" transaction-manager="transactionManager">
		<tx:attributes>
			
			<tx:method name="find*" read-only="true"/>
			<tx:method name="get*" read-only="true"/>
			<tx:method name="purchase" 
				isolation="READ_COMMITTED" 
	no-rollback-for="java.lang.ArithmeticException,java.lang.NullPointerException"
				propagation="REQUIRES_NEW"
				read-only="false"
				timeout="10"/>
		tx:attributes>
	tx:advice>

你可能感兴趣的:(SSM三大框架,spring,java)

移动端城市区县二级联动选择功能实现包 good2know
本文还有配套的精品资源，点击获取简介：本项目是一套为移动端设计的jQuery实现方案，用于简化用户在选择城市和区县时的流程。它包括所有必需文件：HTML、JavaScript、CSS及图片资源。通过动态更新下拉菜单选项，实现城市到区县的联动效果，支持数据异步加载。开发者可以轻松集成此功能到移动网站或应用，并可基于需求进行扩展和优化。1.jQuery移动端解决方案概述jQuery技术简介jQuery
SpringMVC执行流程（原理），通俗易懂国服冰 SpringMVC spring mvc
SpringMVC执行流程（原理），通俗易懂一、图解SpringMVC流程二、进一步理解Springmvc的执行流程1、导入依赖2、建立展示的视图3、web.xml4、spring配置文件springmvc-servlet5、Controller6、tomcat配置7、访问的url8、视图页面一、图解SpringMVC流程图为SpringMVC的一个较完整的流程图，实线表示SpringMVC框架提
深入解析JVM工作原理：从字节码到机器指令的全过程
一、JVM概述Java虚拟机(JVM)是Java平台的核心组件，它实现了Java"一次编写，到处运行"的理念。JVM是一个抽象的计算机器，它有自己的指令集和运行时内存管理机制。JVM的主要职责：加载：读取.class文件并验证其正确性存储：管理内存分配和垃圾回收执行：解释或编译字节码为机器指令安全：提供沙箱环境限制恶意代码二、JVM架构详解JVM由三个主要子系统组成：1.类加载子系统类加载过程分为
Spring进阶 - SpringMVC实现原理之DispatcherServlet处理请求的过程倾听铃的声后端 spring java mvc 开发语言分布式
前文我们有了IOC的源码基础以及SpringMVC的基础，我们便可以进一步深入理解SpringMVC主要实现原理，包含DispatcherServlet的初始化过程和DispatcherServlet处理请求的过程的源码解析。本文是第二篇：DispatcherServlet处理请求的过程的源码解析。@pdaiSpring进阶-SpringMVC实现原理之DispatcherServlet处理请求的
JVM 内存模型深度解析：原子性、可见性与有序性的实现练习时长两年半的程序员小胡 JVM 深度剖析：从面试考点到生产实践 jvm java 内存模型
在了解了JVM的基础架构和类加载机制后，我们需要进一步探索Java程序在多线程环境下的内存交互规则。JVM内存模型（JavaMemoryModel，JMM）定义了线程和主内存之间的抽象关系，它通过规范共享变量的访问方式，解决了多线程并发时的数据一致性问题。本文将从内存模型的核心目标出发，详解原子性、可见性、有序性的实现机制，以及volatile、synchronized等关键字在其中的作用。一、J
Flowable 高级扩展：自定义元素与性能优化实战练习时长两年半的程序员小胡 Flowable 流程引擎实战指南流程图 flowable BPMN 流程引擎 java
在前五篇文章中，我们从基础概念、流程设计、API实战、SpringBoot集成，到外部系统协同，逐步构建了Flowable的应用体系。但企业级复杂场景中，原生功能往往难以满足定制化需求——比如需要特殊的审批规则网关、与决策引擎联动实现动态路由，或是在高并发场景下优化流程引擎性能。本文将聚焦Flowable的高级扩展能力，详解如何自定义流程元素、集成规则引擎，并掌握大型系统中的性能调优策略。一、自定
Java | 多线程经典问题 - 售票 Ada54
一、售票需求1）同一个票池2）多个窗口卖票，不能出售同一张票二、售票问题代码实现（线程与进程小总结，请戳：Java|线程和进程，创建线程）step1：定义SaleWindow类实现Runnable接口，覆盖run方法step2：实例化SaleWindow对象，创建Thread对象，将SaleWindow作为参数传给Thread类的构造函数，然后通过Thread.start()方法启动线程step3
SpringMVC的执行流程
1、什么是MVCMVC是一种设计模式。MVC的原理图如下所示M-Model模型（完成业务逻辑：有javaBean构成，service+dao+entity）V-View视图（做界面的展示jsp，html……）C-Controller控制器（接收请求—>调用模型—>根据结果派发页面2、SpringMVC是什么SpringMVC是一个MVC的开源框架，SpringMVC=Struts2+Spring，
2018-09-27 aop相关蒋超_58dc
1.静态织入，需要使用aspectj专用的compilermaven工程可以采用：https://www.mojohaus.org/aspectj-maven-plugin/2.动态织入，配合spring，创建代理来执行3.
JAVA接口机结构解析秃狼 SpringBoot 八股文 Java java 学习
什么是接口机在Java项目中，接口机通常指用于与外部系统进行数据交互的中间层，负责处理请求和响应的转换、协议适配、数据格式转换等任务。接口机的结构我们的接口机的结构分为两个大部分，外部接口机和内部接口机，在业务的调度上也是通过mq来实现的，只要的目的就是为了解耦合和做差异化。在接口机中主要的方法就是定时任务，消息的发送和消费，其他平台调用接口机只能提供外部接口机的方法进行调用，外部接口机可以提供消
通义万相2.2：开启高清视频生成新纪元 Liudef06小白特殊专栏 AIGC 人工智能人工智能通义万相2.2 图生视频
通义万相2.2：开启高清视频生成新纪元2025年7月28日，中国AI领域迎来里程碑时刻——通义万相团队正式开源其革命性视频生成模型Wan2.2的核心权重，这标志着开源社区首次获得支持720P高清视频生成的先进模型架构。一、架构革新：混合专家系统1.1MoE视频扩散架构通义万相2.2首次将混合专家（MoE）架构引入视频扩散模型，通过双专家系统实现计算效率与模型容量的平衡：classMoEVideoD
最新阿里四面面试真题46道：面试技巧+核心问题+面试心得风平浪静如码
前言做技术的有一种资历，叫做通过了阿里的面试。这些阿里Java相关问题，都是之前通过不断优秀人才的铺垫总结的，先自己弄懂了再去阿里面试，不然就是去丢脸，被虐。希望对大家帮助，祝面试成功，有个更好的职业规划。一，阿里常见技术面1、微信红包怎么实现。2、海量数据分析。3、测试职位问的线程安全和非线程安全。4、HTTP2.0、thrift。5、面试电话沟通可能先让自我介绍。6、分布式事务一致性。7、ni
图论算法经典题目解析：DFS、BFS与拓扑排序实战周童學数据结构与算法深度优先算法图论
图论算法经典题目解析：DFS、BFS与拓扑排序实战图论问题是算法面试中的高频考点，本博客将通过四道LeetCode经典题目（均来自"Top100Liked"题库），深入讲解图论的核心算法思想和实现技巧。涵盖DFS、BFS、拓扑排序和前缀树等知识点，每道题配有Java实现和易错点分析。1.岛屿数量(DFS遍历)问题描述给定一个由'1'(陆地)和'0'(水)组成的二维网格，计算岛屿的数量。岛屿由水平或
【异常】使用 LiteFlow 框架时，提示错误ChainDuplicateException: [chain name duplicate] chainName=categoryChallenge 本本本添哥 002 -进阶开发能力 java
一、报错内容Causedby:com.yomahub.liteflow.exception.ChainDuplicateException:[chainnameduplicate]chainName=categoryChallengeatcom.yomahub.liteflow.parser.helper.ParserHelper.lambda$null$0(ParserHelper.java:1
Java并发核心：线程池使用技巧与最佳实践！ | 多线程篇(五) bug菌¹ Java实战(进阶版)java Java零基础入门 Java并发线程池多线程篇
本文收录于「Java进阶实战」专栏，专业攻坚指数级提升，希望能够助你一臂之力，帮你早日登顶实现财富自由；同时，欢迎大家关注&&收藏&&订阅！持续更新中，up！up！up！！环境说明：Windows10+IntelliJIDEA2021.3.2+Jdk1.8本文目录前言摘要正文何为线程池？为什么需要线程池？线程池的好处线程池使用场景如何创建线程池？线程池的常见配置源码解析案例分享案例代码演示案例运行
Java 队列 tryxr java 开发语言队列
队列一般用什么哪种结构实现队列的特性数据入队列时一定是从尾部插入吗数据出队列时一定是从头部删除吗队列的基本运算有什么队列支持随机访问吗队列的英文表示什么是队列队列从哪进、从哪出队列的进出顺序队列是用哪种结构实现的Queue和Deque有什么区别Queue接口的方法Queue中的add与offer的区别offer、poll、peek的模拟实现如何利用链表实现队列如何利用顺序表实现队列什么叫做双端队列
JVM 内存分配与回收策略：从对象创建到内存释放的全流程
在JVM的运行机制中，内存分配与回收策略是连接对象生命周期与垃圾收集器的桥梁。它决定了对象在堆内存中的创建位置、存活过程中的区域迁移，以及最终被回收的时机。合理的内存分配策略能减少GC频率、降低停顿时间，是优化Java应用性能的核心环节。本文将系统解析JVM的内存分配规则、对象晋升机制，以及实战中的内存优化技巧。一、对象优先在Eden区分配：新生代的“临时缓冲区”大多数情况下，Java对象在新生代
代码随想录算法训练营第三十五天
01背包问题二维题目链接01背包问题二维题解importjava.util.Scanner;publicclassMain{publicstaticvoidmain(String[]args){Scannersc=newScanner(System.in);intM=sc.nextInt();intN=sc.nextInt();int[]space=newint[M];int[]value=new
微信公众号回调java_处理微信公众号消息回调 weixin_39607620 微信公众号回调java
1、背景在上一节中，咱们知道如何接入微信公众号，可是以后公众号会与咱们进行交互，那么微信公众号如何通知到咱们本身的服务器呢？咱们知道咱们接入的时候提供的url是GET/mp/entry，那么公众号以后产生的事件将会以POST/mp/entry发送到咱们本身的服务器上。html2、代码实现，此处仍是使用weixin-java-mp这个框架实现一、引入weixin-java-mpcom.github.
[spring6: Mvc-网关]-源码解析
推荐阅读：[spring6:Mvc-函数式编程]-源码解析GatewayServerMvcAutoConfiguration@AutoConfiguration(after={HttpClientAutoConfiguration.class,RestTemplateAutoConfiguration.class,RestClientAutoConfiguration.class,FilterAu
学C++的五大惊人好处
为什么要学c++学c++有什么用学习c++的好处有1.中考可以加分2.高考可能直接录取3.就业广且工资高4.在未来30--50年c++一定是一个很受欢迎的职业5.c++成功的例子deepsick等AI智能C++语言兼备编程效率和编译运行效率的语言C++语言是C语言功能增强版,在c语言的基础上添加了面向对象编程和泛型编程的支持既继承了C语言高效，简洁，快速和可移植的传统,又具备类似Java、Go等其
Java8 Stream流的sorted()的排序【正序、倒序、多字段排序】 Tony666688888 java windows 开发语言
针对集合排序，java8可以用Stream流的sorted()进行排序。示例Bean以下我们会使用这个Bean来做示例。publicclassOrder{privateStringweight;privateDoubleprice;privateStringdateStr;//忽略getter、setter、构造方法、toString}字段排序首先是比较器Comparator，形式如下：Compa
用代码生成艺术字：设计个性化海报的秘密
本文围绕“用代码生成艺术字：设计个性化海报的秘密”展开，先概述代码生成艺术字在海报设计中的独特价值，接着介绍常用的代码工具（如HTML、CSS、JavaScript等），详细阐述从构思到实现的完整流程，包括字体样式设计、动态效果添加等，还分享了提升艺术字质感的技巧及实际案例。最后总结代码生成艺术字的优势，为设计师提供打造个性化海报的实用指南，助力提升海报设计的独特性与吸引力，符合搜索引擎SEO标准
java实习生40多天有感别拿爱情当饭吃
从5月15日开始，我开始第一步步入社会，我今年大三，在一家上市互联网公司做一名实习生，主要做java后端开发。开始的时候，觉得公司的环境挺不错的，不过因为公司在CBD，所以隔壁的午饭和晚饭都要20+RMB，而且还吃不饱，这让我感觉挺郁闷的。一到下午，我就会犯困（因为饿）。因此，我又不得不买一些干粮在公司屯着。关于技术，有一个比较大的项目在需求调研当中，我们做实习生，就是辅助项目经理，测试功能，并且
大数据技术笔记—spring入门卿卿老祖
篇一spring介绍spring.io官网快速开始Aop面向切面编程，可以任何位置，并且可以细致到方法上连接框架与框架Spring就是IOCAOP思想有效的组织中间层对象一般都是切入service层spring组成前后端分离已学方式，前后台未分离：Spring的远程通信：明日更新创建第一个spring项目来源：科多大数据
大学生入门：初识方法及其易踩坑的点
在java学习过程中，我们不难发现有很多重复使用的功能代码块，每次使用如果都要重新写一遍，岂不是很麻烦，就算是“cv”大法，感觉也不是很方便，那么，有什么办法可以解决这个问题呢？方法！java中，一段可重用的，用于执行特定功能的代码块叫做方法，它可以接收参数、返回结果，并且可以被多次使用。一、方法的基本结构[修饰符]返回值类型方法名([参数列表])[throws异常类型]{//方法体}[throw
[Ljava.lang.Object; cannot be cast to [Ljava.lang.String; 这些不会的
解释：这个错误是很常见的错误，错误的提示已经很清楚了就是java的Object数组不能转换成为String[]数组，这就说明你要转换的数组它本身是Object类型的数组，但是你却非要把它转换为String类的数组，这当然是错误的。示例：[java]viewplaincopypackagecom.dada;importjava.util.ArrayList;importjava.util.List;
HikariCP调试日志深度解析：生产环境故障排查完全指南
HikariCP调试日志深度解析：生产环境故障排查完全指南更新时间：2025年7月4日|作者：资深架构师|适用版本：HikariCP5.x+|难度等级：中高级前言在生产环境中，数据库连接池往往是系统性能的关键瓶颈。HikariCP作为当前最流行的Java连接池，其调试日志包含了丰富的运行时信息，能够帮助我们快速定位和解决各种连接池相关问题。本文将深入解析HikariCP的日志体系，提供一套完整的故
大学社团管理系统（11831） codercode2022 java spring boot spring echarts spring cloud sentinel java-rocketmq
有需要的同学，源代码和配套文档领取，加文章最下方的名片哦一、项目演示项目演示视频二、资料介绍完整源代码（前后端源代码+SQL脚本）配套文档（LW+PPT+开题报告）远程调试控屏包运行三、技术介绍Java语言SSM框架SpringBoot框架Vue框架JSP页面Mysql数据库IDEA/Eclipse开发四、项目截图有需要的同学，源代码和配套文档领取，加文章最下方的名片哦!
今年校招竞争真激烈 12_05
程序员满大街，都要找不到工作了。即使人工智能满大街，我也后悔当初没学机器学习，后悔当初没学Java。C++真难找工作。难道毕了业就失业吗？好担心！
如何用ruby来写hadoop的mapreduce并生成jar包 wudixiaotie mapreduce
ruby来写hadoop的mapreduce，我用的方法是rubydoop。怎么配置环境呢： 1.安装rvm：不说了网上有 2.安装ruby：由于我以前是做ruby的，所以习惯性的先安装了ruby，起码调试起来比jruby快多了。 3.安装jruby： rvm install jruby然后等待安
java编程思想 -- 访问控制权限百合不是茶 java 访问控制权限单例模式
访问权限是java中一个比较中要的知识点,它规定者什么方法可以访问,什么不可以访问一:包访问权限; 自定义包: package com.wj.control; //包 public class Demo { //定义一个无参的方法 public void DemoPackage(){ System.out.println("调用
[生物与医学]请审慎食用小龙虾 comsci 生物
现在的餐馆里面出售的小龙虾,有一些是在野外捕捉的,这些小龙虾身体里面可能带有某些病毒和细菌,人食用以后可能会导致一些疾病,严重的甚至会死亡..... 所以,参加聚餐的时候,最好不要点小龙虾...就吃养殖的猪肉,牛肉,羊肉和鱼,等动物蛋白质
org.apache.jasper.JasperException: Unable to compile class for JSP: 商人shang maven 2.2 jdk1.8
环境： jdk1.8 maven tomcat7-maven-plugin 2.0 原因： tomcat7-maven-plugin 2.0 不知吃 jdk 1.8，换成 tomcat7-maven-plugin 2.2就行，即 <plugin>
你的垃圾你处理掉了吗?GC oloz GC
前序:本人菜鸟，此文研究学习来自网络，各位牛牛多指教　 1.垃圾收集算法的核心思想　　Java语言建立了垃圾收集机制，用以跟踪正在使用的对象和发现并回收不再使用(引用)的对象。该机制可以有效防范动态内存分配中可能发生的两个危险：因内存垃圾过多而引发的内存耗尽，以及不恰当的内存释放所造成的内存非法引用。　　垃圾收集算法的核心思想是：对虚拟机可用内存空间，即堆空间中的对象进行识别
shiro 和 SESSSION 杨白白 shiro
shiro 在web项目里默认使用的是web容器提供的session，也就是说shiro使用的session是web容器产生的，并不是自己产生的，在用于非web环境时可用其他来源代替。在web工程启动的时候它就和容器绑定在了一起，这是通过web.xml里面的shiroFilter实现的。通过session.getSession()方法会在浏览器cokkice产生JESSIONID，当关闭浏览器，此
移动互联网终端淘宝客如何实现盈利小桔子移動客戶端淘客淘寶App
2012年淘宝联盟平台为站长和淘宝客带来的分成收入突破30亿元，同比增长100%。而来自移动端的分成达1亿元，其中美丽说、蘑菇街、果库、口袋购物等App运营商分成近5000万元。可以看出，虽然目前阶段PC端对于淘客而言仍旧是盈利的大头，但移动端已经呈现出爆发之势。而且这个势头将随着智能终端(手机，平板)的加速普及而更加迅猛
wordpress小工具制作 aichenglong wordpress 小工具
wordpress 使用侧边栏的小工具，很方便调整页面结构小工具的制作过程 1 在自己的主题文件中新建一个文件夹(如widget)，在文件夹中创建一个php(AWP_posts-category.php) 小工具是一个类,想侧边栏一样，还得使用代码注册，他才可以再后台使用，基本的代码一层不变 <?php class AWP_Post_Category extends WP_Wi
JS微信分享 AILIKES js
// 所有功能必须包含在 WeixinApi.ready 中进行 WeixinApi.ready(function(Api) { // 微信分享的数据 var wxData = { &nb
封装探讨百合不是茶 JAVA面向对象封装
//封装属性方法将某些东西包装在一起，通过创建对象或使用静态的方法来调用，称为封装；封装其实就是有选择性地公开或隐藏某些信息，它解决了数据的安全性问题，增加代码的可读性和可维护性在 Aname类中申明三个属性，将其封装在一个类中：通过对象来调用例如 1： //属性将其设为私有姓名 name 可以公开
jquery radio/checkbox change事件不能触发的问题 bijian1013 JavaScript jquery
我想让radio来控制当前我选择的是机动车还是特种车，如下所示： <html> <head> <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js" type="text/javascript"><
AngularJS中安全性措施 bijian1013 JavaScript AngularJS 安全性 XSRF JSON漏洞
在使用web应用中，安全性是应该首要考虑的一个问题。AngularJS提供了一些辅助机制，用来防护来自两个常见攻击方向的网络攻击。一.JSON漏洞当使用一个GET请求获取JSON数组信息的时候（尤其是当这一信息非常敏感，
[Maven学习笔记九]Maven发布web项目 bit1129 maven
基于Maven的web项目的标准项目结构 user-project user-core user-service user-web src
【Hive七】Hive用户自定义聚合函数(UDAF) bit1129 hive
用户自定义聚合函数，用户提供的多个入参通过聚合计算(求和、求最大值、求最小值)得到一个聚合计算结果的函数。问题：UDF也可以提供输入多个参数然后输出一个结果的运算，比如加法运算add(3，5)，add这个UDF需要实现UDF的evaluate方法,那么UDF和UDAF的实质分别究竟是什么？ Double evaluate(Double a, Double b)
通过 nginx-lua 给 Nginx 增加 OAuth 支持 ronin47
前言：我们使用Nginx的Lua中间件建立了OAuth2认证和授权层。如果你也有此打算，阅读下面的文档，实现自动化并获得收益。SeatGeek 在过去几年中取得了发展，我们已经积累了不少针对各种任务的不同管理接口。我们通常为新的展示需求创建新模块，比如我们自己的博客、图表等。我们还定期开发内部工具来处理诸如部署、可视化操作及事件处理等事务。在处理这些事务中，我们使用了几个不同的接口来认证： &n
利用tomcat-redis-session-manager做session同步时自定义类对象属性保存不上的解决方法 bsr1983 session
在利用tomcat-redis-session-manager做session同步时，遇到了在session保存一个自定义对象时，修改该对象中的某个属性，session未进行序列化，属性没有被存储到redis中。在 tomcat-redis-session-manager的github上有如下说明： Session Change Tracking As noted in the &qu
《代码大全》表驱动法-Table Driven Approach-1 bylijinnan java 算法
关于Table Driven Approach的一篇非常好的文章： http://www.codeproject.com/Articles/42732/Table-driven-Approach package com.ljn.base; import java.util.Random; public class TableDriven { public
Sybase封锁原理 chicony Sybase
昨天在操作Sybase IQ12.7时意外操作造成了数据库表锁定，不能删除被锁定表数据也不能往其中写入数据。由于着急往该表抽入数据，因此立马着手解决该表的解锁问题。无奈此前没有接触过Sybase IQ12.7这套数据库产品，加之当时已属于下班时间无法求助于支持人员支持，因此只有借助搜索引擎强大的
java异常处理机制 CrazyMizzz java
java异常关键字有以下几个，分别为 try catch final throw throws 他们的定义分别为 try： Opening exception-handling statement. catch： Captures the exception. finally： Runs its code before terminating
hive 数据插入DML语法汇总 daizj hive DML 数据插入
Hive的数据插入DML语法汇总1、Loading files into tables语法：1) LOAD DATA [LOCAL] INPATH 'filepath' [OVERWRITE] INTO TABLE tablename [PARTITION (partcol1=val1, partcol2=val2 ...)]解释：1)、上面命令执行环境为hive客户端环境下： hive>l
工厂设计模式 dcj3sjt126com 设计模式
使用设计模式是促进最佳实践和良好设计的好办法。设计模式可以提供针对常见的编程问题的灵活的解决方案。工厂模式工厂模式（Factory）允许你在代码执行时实例化对象。它之所以被称为工厂模式是因为它负责“生产”对象。工厂方法的参数是你要生成的对象对应的类名称。 Example #1 调用工厂方法（带参数） <?phpclass Example{
mysql字符串查找函数 dcj3sjt126com mysql
FIND_IN_SET(str,strlist) 假如字符串str 在由N 子链组成的字符串列表strlist 中，则返回值的范围在1到 N 之间。一个字符串列表就是一个由一些被‘,’符号分开的自链组成的字符串。如果第一个参数是一个常数字符串，而第二个是type SET列，则 FIND_IN_SET() 函数被优化，使用比特计算。如果str不在strlist 或st
jvm内存管理 easterfly jvm
一、JVM堆内存的划分分为年轻代和年老代。年轻代又分为三部分：一个eden,两个survivor。工作过程是这样的：e区空间满了后，执行minor gc，存活下来的对象放入s0, 对s0仍会进行minor gc，存活下来的的对象放入s1中，对s1同样执行minor gc，依旧存活的对象就放入年老代中；年老代满了之后会执行major gc，这个是stop the word模式，执行
CentOS-6.3安装配置JDK-8 gengzg centos
JAVA_HOME=/usr/java/jdk1.8.0_45 JRE_HOME=/usr/java/jdk1.8.0_45/jre PATH=$PATH:$JAVA_HOME/bin:$JRE_HOME/bin CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib export JAVA_HOME
【转】关于web路径的获取方法 huangyc1210 Web 路径
假定你的web application 名称为news,你在浏览器中输入请求路径： http://localhost:8080/news/main/list.jsp 则执行下面向行代码后打印出如下结果： 1、 System.out.println(request.getContextPath()); //可返回站点的根路径。也就是项
php里获取第一个中文首字母并排序远去的渡口数据结构 PHP
很久没来更新博客了，还是觉得工作需要多总结的好。今天来更新一个自己认为比较有成就的问题吧。最近在做储值结算，需求里结算首页需要按门店的首字母A-Z排序。我的数据结构原本是这样的： Array ( [0] => Array ( [sid] => 2885842 [recetcstoredpay] =&g
java内部类 hm4123660 java 内部类匿名内部类成员内部类方法内部类
　在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。内部类可以间接解决多继承问题,可以使用内部类继承一个类，外部类继承一个类，实现多继承。 &nb
Caused by: java.lang.IncompatibleClassChangeError: class org.hibernate.cfg.Exten zhb8015
maven pom.xml关于hibernate的配置和异常信息如下，查了好多资料，问题还是没有解决。只知道是包冲突，就是不知道是哪个包....遇到这个问题的分享下是怎么解决的。。 maven pom: <dependency> <groupId>org.hibernate</groupId> <ar
Spark 性能相关参数配置详解－任务调度篇 Stark_Summer spark cache cpu 任务调度 yarn
随着Spark的逐渐成熟完善, 越来越多的可配置参数被添加到Spark中来, 本文试图通过阐述这其中部分参数的工作原理和配置思路, 和大家一起探讨一下如何根据实际场合对Spark进行配置优化。由于篇幅较长，所以在这里分篇组织，如果要看最新完整的网页版内容，可以戳这里：http://spark-config.readthedocs.org/，主要是便
css3滤镜 wangkeheng html css
经常看到一些网站的底部有一些灰色的图标，鼠标移入的时候会变亮，开始以为是js操作src或者bg呢，搜索了一下，发现了一个更好的方法：通过css3的滤镜方法。 html代码： <a href='' class='icon'><img src='utv.jpg' /></a> css代码： .icon{-webkit-filter: graysc