什么是Spring
Spring中Bean的配置
ApplicationContext
Spring支持四种依赖注入的方式
Spring中Bean的相互引用
Null值和级联属性
集合属性赋值
Bean自动装配
Bean的作用域
Bean之间的关系
Bean的使用外部属性文件
Spring表达式语言SpEL
Bean的生命周期
Spring AOP面向切面编程
Spring 支持JDBC操作数据库
Spring事务管理
Spring是一个开源框架,是一个IOC(DI)(反转控制或依赖注入)和AOP容器框架
IOC:(反转控制)其思想是反转资源获取的方向,传统的资源查找方式要求组件向容器发起请求查找资源,作为回应,容器适时的返回资源。而应用了IOC之后,则是容器主动的将资源推送给它所管理的组件,组件所要做的仅是选择一种合适的方式来接受资源,这种行为也被称为查找的被动形式。
DI:IOC的另一种表述方式,即组件以一些预先定义好的方式接受来自如容器的资源注入,相对于IOC而言,这种表述更直接。
创建HelloWorld类用于测试
public class HelloWorld {
private String name;
public void setName(String name){
this.name = name;
}
public void sayHello(){
System.out.println("Hello "+name);
}
}
新建一个Bean的xml,在xml配置Bean
通过ApplicationContext获取Bean实例并调用方法
public class Main {
public static void main(String[] args){
//1.创建Spring的IOC容器对象
ApplicationContext mContext = new ClassPathXmlApplicationContext("spring-config.xml");
//2.从IOC容器中获取Bean实例
HelloWorld helloWorld = (HelloWorld) mContext.getBean("helloWorld");//通过id读取Bean
//通过类型获取Bean HelloWorld helloWorld = mContext.getBean(HelloWord.class);缺点就是当有多个相同类型的Bean时无法返回
//3.调用方法
helloWorld.sayHello();
}
}
ClassPathXmlApplicationContext:从类路径下加载配置文件,去新增了两个主要方法 refresh()和close(),让ApplicationContext有了启动,刷新和关闭上下文的功能。
FileSystemXmlApplicationContext:从文件系统中加载配置文件
属性注入:属性注入即通过setter方法注入Bean的属性值或依赖的对象 属性注入使用
属性注释示例
构造方法注入:通过构造方法注入Bean的属性值或依赖的对象,它保证了Bean示例在实例化后就可以使用,构造器注入在
构造方法注入示例
public class Dog {
private String name;
private int age;
private String sex;
public Dog(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
@Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
", age=" + age +
", sex='" + sex + '\'' +
'}';
}
}
]]>
以p命名空间为属性赋值:xmlns:p="http://www.springframework.org/schema/p"
p命名空间赋值示例
工厂方法注入(很少使用,不推荐)
组成应用程序的Bean需要访问其他Bean时需要相互引用,我们可以通过元素或者ref属性来实现Bean之间的引用,也可以使用内部Bean的形式实现引用。
public class Person {
private String name;
private int age;
private Dog dog;
public Person(String name, int age, Dog dog) {
this.name = name;
this.age = age;
this.dog = dog;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Dog getDog() {
return dog;
}
public void setDog(Dog dog) {
this.dog = dog;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", dog=" + dog +
'}';
}
}
ref属性实现Bean的引用
内部Bean实现引用(内部Bean不用指定Bean的Id,内部Bean不可被外部引用)
通过
为级联属性赋值
1、List集合属性
2.Map集合属性
3.配置Properties集合属性
public class DataSouce {
private Properties properties;
public Properties getProperties() {
return properties;
}
public void setProperties(Properties properties) {
this.properties = properties;
}
@Override
public String toString() {
return "DataSouce{" +
"properties=" + properties +
'}';
}
}
DB
21
4.配置单例的集合以便多个Bean引用(以list为例)
Spring IOC容器可以自动装配Bean,需要做的仅仅是在
<!--根据Bean的id 和setter中属性名字相同来配置,若有匹配则装配,若无匹配,则不装配-->
<!--根据Bean的类型和当前Bean属性的类型进行装配->
1.Bean之间的继承
Bean之间的继承通过parent属性来制定其父类,子类配置了的属性按照子类属性的值配置,没配置的属性则按照父类配置来配置(即子类可以覆盖来自父类的继承)。若Bean的class没有指定则必须是一个抽象Bean。
2.Bean之间的依赖
Bean之间的依赖通过depends-on属性来设置,如果被依赖对象如果为设置,则程序会报错。前置依赖的Bean会在本Bean实例化之前创建好,如果需要依赖于多个Bean的话,则可以通过逗号或者空格隔开依赖Bean的Id即可。
所有的Bean在不指定scope时都是单例的(即IOC只会为Bean对象创建一个实例对象,每次获取实例都为一个对象)。
作用域类型:
prototype 原型的,每次获取实例都会产生一个新的实例对象
singleton 单例类型,默认类型
request
session
1.新建一个properties文件
user = root
password = 1230
driverclass = com.mysql.jdbc.briver
jdbcurl = jdbc:mysql://test
2.在xml文件中使用外部属性文件
注意:在使用context时添加命名空间的方法如下。
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.2.xsd"
SpEL是一个支持运行时查询和操作对象图的强大的表达式语言,语法类似于EL,SpEL使用#{}作为界定符,所有在大括号中的字符都将认为是 SpEL。
SpEL作用:
Spring IOC容器对Bean的生命周期进行管理的过程:
在Bean的声明里设置init-method和destroy-method属性,为Bean指定初始化方法和销毁方法
public class Dog {
private String name;
private int age;
private String sex;
private void init(){
System.out.println("Dog init"); //初始化方法
}
private void destroy(){
System.out.println("Dog destroy");//销毁方法
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
}
创建Bean后置处理器:
它允许在调用初始化方法的前后对Bean进行额为的处理,Bean后置处理器对IOC容器里的所有Bean实例逐一处理,而非单一操作。其典型作用:检查Bean的属性的正确性或根据特定的标准更改Bean的属性。
public class MBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throw BeansException {
System.out.println("postProcessBeforeInitialization:"+beanName);
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("postProcessAfterInitialization:"+beanName);
return bean;
}
}
在xml中配置Bean的后置处理器
xml中配置Bean(前面已经用过很多次了不做讲解了)
工厂方式配置Bean
FactoryBean配置Bean
注解方式配置Bean
1.静态工厂方法配置Bean
public class StaticDogFactory {
private static Map dogs = new HashMap<>();
static {
dogs.put("Test1",new Dog("Test1",3,"公"));
dogs.put("Test2",new Dog("Test2",3,"公"));
dogs.put("Test3",new Dog("Test3",3,"公"));
dogs.put("Test4",new Dog("Test4",3,"公"));
}
//静态工厂方法
public static Dog getDog(String name){
return dogs.get(name);
}
}
2.实例工厂方法配置Bean(需要先配置实例工厂对象本身)
public class InstanceDogFactory {
//实例工厂方法
private Map dogs = null;
public InstanceDogFactory(){
dogs = new HashMap<>();
dogs.put("Test1",new Dog("Test1",3,"公"));
dogs.put("Test2",new Dog("Test2",3,"公"));
dogs.put("Test3",new Dog("Test3",3,"公"));
dogs.put("Test4",new Dog("Test4",3,"公"));
}
public Dog getDog(String name){
return dogs.get(name);
}
}
3.通过FactoryBean
public class DogFactoryBean implements FactoryBean {
private String name;
public void setName(String name) {
this.name = name;
}
@Override
public Dog getObject() throws Exception {
return new Dog(name,3,"公");
}
/**
* 返回对象的类型
*/
@Override
public Class> getObjectType() {
return Dog.class;
}
/**
* 是否为单实例
*/
@Override
public boolean isSingleton() {
return true;
}
}
4.通过注解的方式配置Bean(目前使用较为广泛)
当在组件类上使用了特定的注解之后,还需要在Spring的配置文件中声明
base-package属性指定一个需要扫描的基类包,Spring容器将会扫描这个基类包里及其子包中的所有类
当需要扫描多个包时,可以用逗号隔开
如果仅需要扫描特定的类而非基包下的所有类,可使用resource-pattern属性过滤特定的类
特定组件包括:
@Component:基本注解,标识了一个受Spring管理的组件
@Respository:标识持久层组件
@Service:标识服务层(业务层)组件
@Controller:标识表现层组件
annotation通过注解判断是否包含(即不包含那种类型的注解)
assignable指定不包含具体类
resource-pattern="repository/*.class">
组件配置
@Autowired:注解自动装配具有兼容类型的单个Bean属性构造器,普通字段,一切具有参数的方法都可以应用@Autowired注解(@Autowired注解的对象必须是一个允许自动装配的类,或者设置@Autowired的required值为false,允许装配不上,如果被装配的类有多个实现,就会根据其名字去查询装配对象,如果未指定名字则会报错,还可以通过在@Autowired注解下加@Qualifier("BeanClassName")来指定装配的Bean的类型)。
@Controller
public class UserController {
//@Autowired(required = false)
//@Qualifier("UserRepositoryIpml")
private UserService userService;
@Autowired(required = false) //即使装配不上也不报错,设置为null
@Qualifier("UserRepositoryIpml")
public void setUserService(UserService userService) {
this.userService = userService;
}
// public void setUserService(@Qualifier("UserRepositoryIpml") UserService userService) {
// this.userService = userService;
// }
public void execute(){
System.out.println("UserController execute...");
userService.add();
}
}
@Repository("userRepository")//为Bean指定id
public class UserRepositoryIpml implements UserRepository {
@Override
public void save() {
System.out.println("UserRepositoryIpml save...");
}
}
AOP:是一种新的方法论,是对传统OOP(面向对象编程)的补充,在使用AOP编程时,仍然需要定义公共功能,并且不必修改影响的类。这样一来横切关注点就被模块化到特殊的对象(切面)里了。好处:1、每个事物逻辑位于一个位置,代码不分散,便于维护和升级。2、业务模块更简洁,只包含核心业务代码,实现了解耦合。
示例需要用到的类
public interface ArithmeticCalculator {
int add(int i,int j);
int sub(int i,int j);
int mul(int i,int j);
int div(int i,int j);
}
@Component
public class ArithmeticCalculatorIpml implements ArithmeticCalculator {
@Override
public int add(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;
}
}
1.动态代理方式实现日志(开发时不常使用)
/**
* 动态代理
*/
public class ArithmeticCalculatorLoggingProxy {
//要代理的对象
private ArithmeticCalculator target;
public ArithmeticCalculatorLoggingProxy(ArithmeticCalculator target){
this.target = target;
}
public ArithmeticCalculator getLoggingProxy(){
ArithmeticCalculator proxy = null;
//类加载器 用于加载被代理对象
ClassLoader loader = target.getClass().getClassLoader();
//被代理对象实现了哪些接口 具有哪些方法
Class [] interfaces = new Class[]{ArithmeticCalculator.class};
//当调用代理对象其中的方法时,该执行的具体方法
InvocationHandler handler = new InvocationHandler() {
/**
* @param proxy 正在返回的那个代理对象,一般情况下,在invoke中都不实用该对象
* @param method 正在被调用的方法
* @param args 调用方法时传入的参数
* @return
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String methodName = method.getName();
//日志
System.out.println("The method:"+methodName+" begins with "+ Arrays.asList(args));
//执行方法
Object result = method.invoke(target,args);
//日志
System.out.println("The method:"+methodName+" ends with "+ result);
return result;
}
};
proxy = (ArithmeticCalculator) Proxy.newProxyInstance(loader,interfaces,handler);
return proxy;
}
}
//使用动态代理
ArithmeticCalculator target = new ArithmeticCalculatorIpml();
ArithmeticCalculator proxy = new ArithmeticCalculatorLoggingProxy(target).getLoggingProxy();
System.out.println(proxy.add(1,2));
2.Spring AOP通知
AspectJ:java社区里最完整最流行的AOP框架,在Spring2.0以后可以使用。IDEA在使用AspectJ要先通过jar包的方式导入。
AspectJ支持5中类型的通知注解:
@Before 前置通知,在方法执行前调用
@After 后置通知,在方法区执行后调用
@AfterRunning 返回通知,在方法返回结果之后执行
@AfterThrowing 异常通知,在方法抛出异常后执行
@Around 环绕通知,围绕着方法执行
创建切面类
/**
* 日志切面
*/
@Aspect //声明其为一个切面
@Component
public class LoggingAspect {
//申明该方法为一个前置通知
@Before(value = "execution(public int Spring.aop.ArithmeticCalculatorIpml.*(..))")//匹配所有参数类型的方法
//@Before(value = "execution(public int Spring.aop.ArithmeticCalculatorIpml.*(..))")//匹配指定参数类型的方法
//@Before(value = "execution(public int Spring.aop.*.*(..))")//匹配包下的所有类的所有方法
public void beforeMethod(JoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
List
在xml中启动Aspect
通过@Order注解给切面添加优先级,值越小优先级越高
@Order(1)
@Aspect //声明其为一个切面
@Component
public class LoggingAspect {
//申明该方法为一个前置通知
@Before(value = "execution(public int Spring.aop.ArithmeticCalculatorIpml.*(..))")//匹配所有参数类型的方法
//@Before(value = "execution(public int Spring.aop.ArithmeticCalculatorIpml.*(..))")//匹配指定参数类型的方法
//@Before(value = "execution(public int Spring.aop.*.*(..))")//匹配包下的所有类的所有方法
public void beforeMethod(JoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
List
@Aspect //声明其为一个切面
@Component
public class LoggingAspect {
@Pointcut("execution(public int Spring.aop.ArithmeticCalculatorIpml.*(..))")
public void AspectPoint(){}
//申明该方法为一个前置通知
@Before(value = "AspectPoint()")//匹配所有参数类型的方法
//@Before(value = "execution(public int Spring.aop.ArithmeticCalculatorIpml.*(..))")//匹配指定参数类型的方法
//@Before(value = "execution(public int Spring.aop.*.*(..))")//匹配包下的所有类的所有方法
public void beforeMethod(JoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
List
c3p0连接池 jar包c3p0下载地址
注意:c3p0下的mchange-commons-java.jar,c3p0-oracle-thin-extras.jar,c3p0.jar这三个jar包都需要导入
junit 单元测试 jar包junit下载地址
mysql-connector-java下载地址
创建外部文件存储连接数据库的相关数据
jdbc.user=你的用户名
jdbc.password=你的密码
jdbc.driverClass=com.mysql.cj.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql://127.0.0.1:3306/spring4?serverTimezone=UTC //后面serverTimezone=UTC这个表示设置时区 spring4是我的数据库名称
jdbc.initPoolSize=5
jdbc.maxPoolSize=10
配置Bean文件
创建单元测试测试是否连通
public class JdbcTest {
private ApplicationContext mContext = null;
{
mContext = new ClassPathXmlApplicationContext("beans-jdbc.xml");
}
@Test
public void Test(){
DataSource dataSource = mContext.getBean(DataSource.class);
try {
System.out.println(dataSource.getConnection());
} catch (SQLException e) {
e.printStackTrace();
}
}
}
当控制面板输出com.mchange.v2.c3p0.impl.NewProxyConnection@48524010 [wrapping: com.mysql.cj.jdbc.ConnectionImpl@4b168fa9]类似这种信息时表示连接数据库成功。
会使用到的类
public class User {
private String username;
private int id;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
}
配置jdbcTemplate的Bean
使用jdbcTemplate更新数据库
public void testUpdate(){
jdbcTemplate = (JdbcTemplate) mContext.getBean("jdbcTemplate");
String sql = "UPDATE user SET username = ? WHERE id = ?";//问号表示需要传入的参数
jdbcTemplate.update(sql,"name2",1);
}
使用jdbcTemplate插入数据
public void testInsert(){
jdbcTemplate = (JdbcTemplate) mContext.getBean("jdbcTemplate");
String sql = "INSERT INTO user(username,id) VALUES (?,?)";
List
使用jdbcTemplate查询指定数据
public void testQueryForObject(){
jdbcTemplate = (JdbcTemplate) mContext.getBean("jdbcTemplate");
String sql = "SELECT * FROM user WHERE id = ?";
RowMapper rowMapper = new BeanPropertyRowMapper<>(User.class);
User user = jdbcTemplate.queryForObject(sql,rowMapper,1);
System.out.println("username:"+user.getUsername());
}
使用jdbcTemplate查询所有表内所有信息
public void testQueryForAll(){
jdbcTemplate = (JdbcTemplate) mContext.getBean("jdbcTemplate");
String sql = "SELECT * FROM user";
RowMapper rowMapper = new BeanPropertyRowMapper<>(User.class);
List users = jdbcTemplate.query(sql,rowMapper);
System.out.println("username:"+users.toString());
}
事务就是一系列的动作,它们都被当作一个单独的工作单元,这些动作要么全部完成,要么全部不起作用,当某一任务出错后我们需要回滚数据。
基于注解方式声明事务
1.配置事务管理器
2.通过注解声明事务
通过@Transactional为方法添加上事物注解
3.事务的传播行为(即一个事物被另一个事物引用时的行为)
事务的传播行为
REQUIRED_NEW:表示当前方法必须在其自己的事务中运行,一个新的事务将会被启动。如果存在当前事务,在该方法执行期间,当前事务会被挂起。
REQUIRED:表示当前方法必须运行在事务中,如果当前事务存在,方法将会在该事物中运行。否则,会启动一个新的事务。
SUPPORTS:表示当前方法不需要事务上下文,但是如果存在当前事务的话,那么该方法会在这个事务中运行。
MANDATORY:表示该方法必须在事务中运行,但如果当前事务不存在,则会抛出一个异常。
NOT_SUPPORTED:表示该方法不应该运行在它自己的事务中。如果存在当前事务,在该方法运行期间,当前事务将被挂起。
NEVER:表示当前方法不应该运行在事务上下文中,如果当前正有一个事务在运行,则抛出异常。
NESTED:表示如果当前已经存在一个事务,那么该方法将会嵌套在事务中运行,嵌套事务可以独立于当前事务进行单独的提交或回滚,如果当前事务不存在,那么其行为与REQUIRED一样。
4.通过propagation指定事务的传播行为,其默认值为REQUIRED
@Transactional(propagation = Propagation.REQUIRED)
5.使用isolation指定事务的隔离级别,最常用的取值为READ_COMMITTED
默认情况下Spring的声明事务将对所有的运行时异常进行回滚,可以通过对应属性进行设置