Java进阶:Spring
零、通过Maven创建Spring项目
- 新建Spring文件夹
- 使用idea打开,并新建Module
- 选择Maven直接nect
- 填写GroupID和ArtifactID,点击Finish
GroupID 是项目组织唯一的标识符,实际对应JAVA的包的结构,是main目录里java的目录结构。
ArtifactID是项目的唯一的标识符,实际对应项目的名称,就是项目根目录的名称。 - 点击File,选择Project Structure
- 设置好project中的几项
- 选择Facets,点击+号,选择web
- 选择需要添加的module
- 修改一下路径
- 创建完成
- 同理创建itheima_spring_ioc
一、Spring基础
1. spring概述
1.1 Spring是什么(理解)
Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架,以 IoC(Inverse Of Control:反转控制)和 AOP(Aspect Oriented Programming:面向切面编程)为内核。
提供了 展现层 SpringMVC和 持久层 Spring JDBCTemplate以及 业务层事务管理等众多的企业级应用技术,还能整合开源世界众多著名的第三方框架和类库,逐渐成为使用最多的Java EE 企业应用开源框架
1.2 Spring发展历程 (了解)
1997年,IBM提出了EJB的思想。
1998年,SUN指定开发标准规范EJB1.0.
1999年,EJB1.1发布。
2001年,EJB2.0发布。
2003年,EJB2.1发布。
2006年,EJB3.0发布。
Rod Johnson ( Spring 之父)
Expert One-to-One J2EE Design and Development(2002)阐述了J2EE使用EJB开发设计的优点和解决方案。
Expert One-to-One J2EE Development without EJB(2004)阐述了J2EE开发部使用EJB的解决方式(Spring雏形)。
2017 年9 月份发布了 Spring 的最新版本 Spring5.0通用版(GA)
1.3 Spring的优势(理解)
方便解耦,简化开发
通过Spring提供的IoC容器,可以将对象间的依赖关系交由Spring进行控制,避免硬编码所造成的过度耦合。
用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码,可以更专注于上层的应用。AOP 编程的支持
通过Spring的AOP功能,方便进行面向切面变成,许多不容易用传统OOP实现的功能可以通过AOP轻松实现。AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,
OOP为Object Oriented Programming的缩写,意为:面向对象编程。。声明式事务的支持
可以将我们从单调烦闷的事务管理代码中解脱出来,通过声明式方式灵活的进行事务管理,提高开发效率和质量。方便程序的测试
可以用非容器依赖的编程方式进行几乎所有的测试工作,测试不再是昂贵的操作,而是随手可做的事情。方便集成各种优秀框架
Spring对各种优秀框架(Struts、Hibemate、Hessian、Quartz等)的支持。降低JavaEE API的使用难度
Spring 对 JavaEE API(如JDBC、JavaMail、远程调用等)进行了薄薄的封装层,使得这些API的使用难度大为降低。Java源码是经典学习带典范
Spring的源代码设计精妙、结构清晰、匠心独拥,处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。它的源代码无疑是Java技术的最佳实践范例。
1.4 Spring的体系结构(了解)
2. spring快速入门
2.1 Spring程序开发步骤
导入 Spring 开发的基本包坐标
编写 Dao 接口和实现类
创建 Spring 核心配置文件
在 Spring 配置文件中配置 UserDaoImpl
新建applicationContext.xml
配置UserDaoImpl使用 Spring 的 API 获得 Bean 实例
新建UserDaoDemo
2.1.1 导入Spring开发的基本包坐标
<properties><spring.version>5.0.5.RELEASE</spring.version>
</properties>
<!--导入spring的context坐标,context依赖core、beans、expression-->
<dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>${spring.version}</version></dependency>
</dependencies>
2.1.2 编写Dao接口和实现类
public interface UserDao { public void save();
}public class UserDaoImpl implements UserDao { @Override public void save() {System.out.println("UserDao save method running....");}
}
2.1.3 创建Spring核心配置文件
在类路径下(resources)创建applicationContext.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>
2.1.4在Spring配置文件中配置UserDaoImpl
<?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="userDao" class="com.itheima.dao.impl.UserDaoImpl"></bean>
</beans>
2.1.5 使用Spring的API获得Bean实例
@Test
public void test1(){ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");UserDao userDao = (UserDao) applicationContext.getBean("userDao"); userDao.save();}
3. Spring配置文件
3.1 Bean标签基本配置
用于配置对象交由Spring 来创建。
默认情况下它调用的是类中的无参构造函数,如果没有无参构造函数则不能创建成功。
基本属性:
id:Bean实例在Spring容器中的唯一标识
class:Bean的全限定名称
3.2 Bean标签范围配置
scope:指对象的作用范围,取值如下:
取值范围 | 说明 |
---|---|
singleton | 默认值,单例的 |
prototype | 多例的 |
request | WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中 |
session | WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中 |
global session | WEB 项目中,应用在 Portlet 环境,如果没有 Portlet 环境那么globalSession 相当于 session |
- 当scope的取值为singleton时
Bean的实例化个数:1个
Bean的实例化时机:当Spring核心文件被加载时,实例化配置的Bean实例
Bean的生命周期:
- 对象创建:
当应用加载,创建容器时,对象就被创建了
- 对象运行:只要容器在,对象一直活着
- 对象销毁:当应用卸载,销毁容器时,对象就被销毁了
- 当scope的取值为prototype时
Bean的实例化个数:多个
Bean的实例化时机:当调用getBean()方法时实例化Bean
- 对象创建:
当使用对象时,创建新的对象实例
- 对象运行:只要对象在使用中,就一直活着
- 对象销毁:当对象长时间不用时,被 Java 的垃圾回收器回收了
3.3 Bean生命周期配置
- init-method:指定类中的初始化方法名称
- destroy-method:指定类中销毁方法名称
3.4 Bean实例化三种方式
3.4.1使用无参构造方法实例化
它会根据默认无参构造方法来创建类对象,如果bean中没有默认无参构造函数,将会创建失败
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
3.4.1工厂静态方法实例化
工厂的静态方法返回Bean实例
public class StaticFactoryBean {public static UserDao createUserDao(){ return new UserDaoImpl();}
}
<bean id="userDao" class="com.itheima.factory.StaticFactoryBean" factory-method="createUserDao" />
3.4.3工厂实例方法实例化
工厂的非静态方法返回Bean实例
public class DynamicFactoryBean { public UserDao createUserDao(){ return new UserDaoImpl(); }
}
<bean id="factoryBean" class="com.itheima.factory.DynamicFactoryBean"/>
<bean id="userDao" factory-bean="factoryBean" factory-method="createUserDao"/>
3.5 Bean的依赖注入入门
①创建 UserService,UserService 内部在调用 UserDao的save() 方法
public class UserServiceImpl implements UserService {@Overridepublic void save() {ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml"); UserDao userDao = (UserDao) applicationContext.getBean("userDao"); userDao.save();}}
②将 UserServiceImpl 的创建权交给 Spring
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl"/>
③从 Spring 容器中获得 UserService 进行操作
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = (UserService) applicationContext.getBean("userService");
userService.save();
3.6 Bean的依赖注入概念
依赖注入(Dependency Injection):它是 Spring 框架核心 IC 的具体实现。
在编写程序时,通过控制反转,把对象的创建交给了 Spring,但是代码中不可能出现没有依赖的情况。
IOC 解耦只是降低他们的依赖关系,但不会消除。例如:业务层仍会调用持久层的方法。
那这种业务层和持久层的依赖关系,在使用 Spring 之后,就让 Spring 来维护了。
简单的说,就是坐等框架把持久层对象传入业务层,而不用我们自己去获取
3.7 Bean的依赖注入方式
①构造方法
创建有参构造
public class UserServiceImpl implements UserService {@Override
public void save() {ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml"); UserDao userDao = (UserDao) applicationContext.getBean("userDao"); userDao.save();}}
配置Spring容器调用有参构造时进行注入
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl"> <constructor-arg name="userDao" ref="userDao"></constructor-arg>
</bean>
②set方法
在UserServiceImpl中添加setUserDao方法
public class UserServiceImpl implements UserService {private UserDao userDao;public void setUserDao(UserDao userDao) {this.userDao = userDao; } @Override public void save() { userDao.save();}
}
配置Spring容器调用set方法进行注入
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl"><property name="userDao" ref="userDao"/>
</bean>
set方法:P命名空间注入
P命名空间注入本质也是set方法注入,但比起上述的set方法注入更加方便,主要体现在配置文件中,如下:
首先,需要引入P命名空间:
xmlns:p="http://www.springframework.org/schema/p"
其次,需要修改注入方式
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl" p:userDao-ref="userDao"/>
3.8 Bean的依赖注入的数据类型
上面的操作,都是注入的引用Bean,处了对象的引用可以注入,普通数据类型,集合等都可以在容器中进行注入。
注入数据的三种数据类型
- 普通数据类型 用value
- 引用数据类型 用ref
- 集合数据类型
其中引用数据类型,此处就不再赘述了,之前的操作都是对UserDao对象的引用进行注入的,下面将以set方法注入为例,演示普通数据类型和集合数据类型的注入。
Bean的依赖注入的数据类型
(1)普通数据类型的注入 用value
public class UserDaoImpl implements UserDao {private String company;private int age;public void setCompany(String company) {this.company = company;}public void setAge(int age) {this.age = age;}public void save() {System.out.println(company+"==="+age);System.out.println("UserDao save method running...."); }
}
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"><property name="company" value="传智播客"></property><property name="age" value="15"></property>
</bean>
(2)集合数据类型(List)的注入
public class UserDaoImpl implements UserDao {private List<String> strList;public void setStrList(List<String> strList) {this.strList = strList;}public void save() {System.out.println(strList);System.out.println("UserDao save method running....");}
}
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"><property name="strList"><list><value>aaa</value><value>bbb</value><value>ccc</value></list></property>
</bean>
(3)集合数据类型(List)的注入
public class UserDaoImpl implements UserDao {private List<User> userList;public void setUserList(List<User> userList) {this.userList = userList; }
public void save() {System.out.println(userList);System.out.println("UserDao save method running....");}
}
<bean id="u1" class="com.itheima.domain.User"/>
<bean id="u2" class="com.itheima.domain.User"/>
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"><property name="userList"><list><bean class="com.itheima.domain.User"/><bean class="com.itheima.domain.User"/><ref bean="u1"/><ref bean="u2"/> </list></property>
</bean>
(4)集合数据类型( Map<String,User> )的注入
public class UserDaoImpl implements UserDao {private Map<String,User> userMap;public void setUserMap(Map<String, User> userMap) {this.userMap = userMap;}
public void save() { System.out.println(userMap);System.out.println("UserDao save method running....");}
}
<bean id="u1" class="com.itheima.domain.User"/>
<bean id="u2" class="com.itheima.domain.User"/>
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"><property name="userMap"><map> <entry key="user1" value-ref="u1"/><entry key="user2" value-ref="u2"/></map></property>
</bean>
(5)集合数据类型(Properties)的注入
public class UserDaoImpl implements UserDao {private Properties properties;public void setProperties(Properties properties) {this.properties = properties;}public void save() {System.out.println(properties);System.out.println("UserDao save method running....");}
}
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"><property name="properties"><props><prop key="p1">aaa</prop><prop key="p2">bbb</prop> <prop key="p3">ccc</prop></props></property>
</bean>
3.9 引入其他配置文件(分模块开发)
实际开发中,Spring的配置内容非常多,这就导致Spring配置很繁杂且体积很大,所以,可以将部分配置拆解到其他配置文件中,而在Spring主配置文件通过import标签进行加载
<import resource="applicationContext-xxx.xml"/>
3.10 知识要点
Spring的重点配置
<bean>标签id属性:在容器中Bean实例的唯一标识,不允许重复。class属性:要实例化的Bean的全限定名。scope属性:bean的作用范围,常用Singleton(默认)和prototype<property>标签:属性注入name属性:属性名称value属性:注入的普通属性值ref属性:注入的对象引用值<list>标签<map>标签<properties>标签<constructor-arg>标签
<import>标签:导入其他的Spring的分文件
4. spring相关API
4.1 ApplicationContext的继承体系
applicationContext:接口类型,代表应用上下文,可以通过其实例获得 Spring 容器中的 Bean 对象
4.2 ApplicationContext的实现类
ClassPathXmlApplicationContext
:它是从类的根路径下加载配置文件 推荐使用这种FileSystemXmlApplicationContext
:它是从磁盘路径上加载配置文件,配置文件可以在磁盘的任意位置。AnnotationConfigApplicationContext
:当使用注解配置容器对象时,需要使用此类来创建 spring 容器。它用来读取注解。
4.3 getBean()方法使用
源码:
public Object getBean(String name) throws BeansException { assertBeanFactoryActive(); return getBeanFactory().getBean(name);
}
public <T> T getBean(Class<T> requiredType) throws BeansException { assertBeanFactoryActive();return getBeanFactory().getBean(requiredType);
}
其中,当参数的数据类型是字符串时,表示根据Bean的id从容器中获得Bean实例,返回是Object,需要强转。
当参数的数据类型是Class类型时,表示根据类型从容器中匹配Bean实例,当容器中相同类型的Bean有多个时,则此方法会报错
getBean()方法使用
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");UserService userService1 = (UserService) applicationContext.getBean("userService");UserService userService2 = applicationContext.getBean(UserService.class);
二、SpringIOC和DI注解开发
1.Spring配置数据源
1.1 数据源(连接池)的作用
数据源(连接池)是提高程序性能如出现的
事先实例化数据源,初始化部分连接资源
使用连接资源时从数据源中获取
使用完毕后将连接资源归还给数据源
常见的数据源(连接池):DBCP、C3P0、BoneCP、Druid等
开发步骤
①导入数据源的坐标和数据库驱动坐标
②创建数据源对象
③设置数据源的基本连接数据
④使用数据源获取连接资源和归还连接资源
1.2 数据源的手动创建
①导入c3p0和druid的坐标
<!-- C3P0连接池 -->
<dependency><groupId>c3p0</groupId><artifactId>c3p0</artifactId><version>0.9.1.2</version>
</dependency>
<!-- Druid连接池 -->
<dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.1.10</version>
</dependency>
①导入mysql数据库驱动坐标
<!-- mysql驱动 -->
<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.22</version>
</dependency>
②创建C3P0连接池
@Test
// 测试手动创建 c3p0 数据源
public void test1() throws PropertyVetoException, SQLException {ComboPooledDataSource dataSource = new ComboPooledDataSource();dataSource.setDriverClass("com.mysql.jdbc.Driver");dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test?useUnicode=true & characterEncoding=UTF-8 & serverTimezone=Asia/Shanghai");dataSource.setUser("root");dataSource.setPassword("131415");Connection connection = dataSource.getConnection();System.out.println(connection);connection.close();
}
②创建Druid连接池
@Test
public void test2() throws Exception {DruidDataSource dataSource = new DruidDataSource();dataSource.setDriverClassName("com.mysql.jdbc.Driver");dataSource.setUrl("jdbc:mysql://localhost:3306/test?useUnicode=true & characterEncoding=UTF-8 & serverTimezone=Asia/Shanghai");dataSource.setUsername("root");dataSource.setPassword("131415");DruidPooledConnection connection = dataSource.getConnection();System.out.println(connection);connection.close();
}
③提取jdbc.properties配置文件:resources目录下新建jdbc.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url="jdbc:mysql://localhost:3306/test?useUnicode=true & characterEncoding=UTF-8 & serverTimezone=Asia/Shanghai"
jdbc.username=root
jdbc.password=131415
④读取jdbc.properties配置文件创建连接池
public void test3() throws Exception {// 1. 读取配置文件ResourceBundle rb = ResourceBundle.getBundle("jdbc");// 2. 赋值String driver = rb.getString("jdbc.driver");String url = rb.getString("jdbc.url");String username = rb.getString("jdbc.username");String password = rb.getString("jdbc.password");// 3. 创建数据源对象,设置连接参数ComboPooledDataSource dataSource = new ComboPooledDataSource();dataSource.setDriverClass(driver);dataSource.setJdbcUrl(url);dataSource.setUser(username);dataSource.setPassword(password);Connection connection = dataSource.getConnection();System.out.println(connection);connection.close();}
1.3 Spring配置数据源
可以将DataSource的创建权交由Spring容器去完成
DataSource有无参构造方法,而Spring默认就是通过无参构造方法实例化对象的
DataSource要想使用需要通过set方法设置数据库连接信息,而Spring可以通过set方法进行字符串注入
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"><property name="driverClass" value="com.mysql.jdbc.Driver"/><property name="jdbcUrl"value="jdbc:mysql://localhost:3306/test?useUnicode=true & characterEncoding=UTF-8 & serverTimezone=Asia/Shanghai"/><property name="user" value="root"/><property name="password" value="131415"/>
</bean>
测试从容器当中获取数据源
@Test
// 测试Spring容器产生数据源对象
public void test4() throws Exception {ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");DataSource dataSource = app.getBean(DataSource.class);Connection connection = dataSource.getConnection();System.out.println(connection);connection.close();
}
1.4 抽取jdbc配置文件
applicationContext.xml加载jdbc.properties配置文件获得连接信息。
首先,需要引入context命名空间和约束路径:
命名空间:xmlns:context=“http://www.springframework.org/schema/context”
约束路径:http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
<context:property-placeholder location="classpath:jdbc.properties"/>
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"><property name="driverClass" value="${jdbc.driver}"/><property name="jdbcUrl" value="${jdbc.url}"/><property name="user" value="${jdbc.username}"/><property name="password" value="${jdbc.password}"/>
</bean>
1.5 知识要点
Spring容器加载properties文件
<context:property-placeholder location="classpath:xx.properties"/>
<property name="" value="${key}"/>
2. Spring注解开发
2.1 Spring原始注解
Spring是轻代码而重配置的框架,配置比较繁重,影响开发效率,所以注解开发是一种趋势,注解代替xml配置文件可以简化配置,提高开发效率。
Spring原始注解主要是替代的配置
注解 | 说明 |
---|---|
@Component | 使用在类上用于实例化Bean |
@Controller | 使用在web层类上用于实例化Bean |
@Service | 使用在service层类上用于实例化Bean |
@Repository | 使用在dao层类上用于实例化Bean |
@Autowired | 使用在字段上用于根据类型依赖注入 |
@Qualifier | 结合@Autowired一起使用用于根据名称进行依赖注入 |
@Resource | 相当于@Autowired+@Qualifier,按照名称进行注入 |
@Value | 注入普通属性 |
@Scope | 标注Bean的作用范围 |
@PostConstruct | 使用在方法上标注该方法是Bean的初始化方法 |
@PreDestroy | 使用在方法上标注该方法是Bean的销毁方法 |
注意:
使用注解进行开发时,需要在applicationContext.xml中配置组件扫描,作用是指定哪个包及其子包下的Bean需要进行扫描以便识别使用注解配置的类、字段和方法。
<!--注解的组件扫描-->
<context:component-scan base-package="com.itheima"></context:component-scan>
使用@Compont或@Repository标识UserDaoImpl需要Spring进行实例化。
//@Component("userDao")
@Repository("userDao")
public class UserDaoImpl implements UserDao {@Overridepublic void save() {System.out.println("save running... ...");}
}
使用@Compont或@Service标识UserServiceImpl需要Spring进行实例化
使用@Autowired或者@Autowired+@Qulifier或者@Resource进行userDao的注入
//@Component("userService")
@Service("userService")
public class UserServiceImpl implements UserService {/*@Autowired@Qualifier("userDao")*/@Resource(name="userDao")private UserDao userDao;@Overridepublic void save() { userDao.save();}
}
使用@Value进行字符串的注入
@Repository("userDao")
public class UserDaoImpl implements UserDao {@Value("注入普通数据")private String str;@Value("${jdbc.driver}")private String driver;@Overridepublic void save() {System.out.println(str);System.out.println(driver);System.out.println("save running... ...");}
}
使用@Scope标注Bean的范围
//@Scope("prototype")
@Scope("singleton")
public class UserDaoImpl implements UserDao {//此处省略代码
}
使用@PostConstruct标注初始化方法,使用@PreDestroy标注销毁方法
@PostConstruct
public void init(){System.out.println("初始化方法....");
}
@PreDestroy
public void destroy(){System.out.println("销毁方法.....");
}
2.2 Spring新注解
使用上面的注解还不能全部替代xml配置文件,还需要使用注解替代的配置如下:
- 非自定义的Bean的配置:<bean>
- 加载properties文件的配置:<context:property-placeholder>
- 组件扫描的配置:<context:component-scan>
- 引入其他文件:<import>
注解 | 说明 |
---|---|
@Configuration | 用于指定当前类是一个 Spring 配置类,当创建容器时会从该类上加载注解 |
@ComponentScan | 用于指定 Spring 在初始化容器时要扫描的包。 作用和在 Spring 的 xml 配置文件中的 <context:component-scan base-package=“com.itheima”/>一样 |
@Bean | 使用在方法上,标注将该方法的返回值存储到 Spring 容器中 |
@PropertySource | 用于加载.properties 文件中的配置 |
@Import | 用于导入其他配置类 |
@Configuration
@ComponentScan
@Import
@Configuration
@ComponentScan("com.itheima")
@Import({DataSourceConfiguration.class})
public class SpringConfiguration {}
@PropertySource
@value
@PropertySource("classpath:jdbc.properties")
public class DataSourceConfiguration {@Value("${jdbc.driver}")private String driver;@Value("${jdbc.url}")private String url;@Value("${jdbc.username}")private String username;@Value("${jdbc.password}")private String password;
@Bean
@Bean(name="dataSource")
public DataSource getDataSource() throws PropertyVetoException { ComboPooledDataSource dataSource = new ComboPooledDataSource(); dataSource.setDriverClass(driver);dataSource.setJdbcUrl(url);dataSource.setUser(username);dataSource.setPassword(password);return dataSource;
}
测试加载核心配置类创建Spring容器
package com.itheima.web;import com.itheima.config.SpringConfiguration;
import com.itheima.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;public class UserController {public static void main(String[] args) {ApplicationContext app = new AnnotationConfigApplicationContext(SpringConfiguration.class);UserService userService = app.getBean(UserService.class);userService.save();}
}
3. Spring整合Junit
3.1 原始Junit测试Spring的问题
在测试类中,每个测试方法都有以下两行代码:
ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");IAccountService as = ac.getBean("accountService",IAccountService.class);
这两行代码的作用是获取容器,如果不写的话,直接会提示空指针异常。所以又不能轻易删掉。
3.2 上述问题解决思路
- 让SpringJunit负责创建Spring容器,但是需要将配置文件的名称告诉它
- 将需要进行测试Bean直接在测试类中进行注入
3.3 Spring集成Junit步骤
① 导入spring集成Junit的坐标
② 使用@Runwith注解替换原来的运行期
③ 使用@ContextConfiguration指定配置文件或配置类
④ 使用@Autowired注入需要测试的对象
⑤ 创建测试方法进行测试
3.4 Spring集成Junit代码实现
①导入spring集成Junit的坐标
<!--此处需要注意的是,spring5 及以上版本要求 junit 的版本必须是 4.12 及以上-->
<dependency><groupId>org.springframework</groupId><artifactId>spring-test</artifactId><version>5.0.2.RELEASE</version>
</dependency>
<dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope>
</dependency>
②使用@Runwith注解替换原来的运行期
@RunWith(SpringJUnit4ClassRunner.class)
public class SpringJunitTest {}
③使用@ContextConfiguration指定配置文件或配置类
@RunWith(SpringJUnit4ClassRunner.class)
//加载spring核心配置文件
//@ContextConfiguration(value = {"classpath:applicationContext.xml"})
//加载spring核心配置类
@ContextConfiguration(classes = {SpringConfiguration.class})
public class SpringJunitTest {}
④使用@Autowired注入需要测试的对象
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {SpringConfiguration.class})
public class SpringJunitTest {@Autowiredprivate UserService userService;
}
⑤创建测试方法进行测试
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {SpringConfiguration.class})public class SpringJunitTest {@Autowiredprivate UserService userService;@Testpublic void testUserService(){userService.save();}
}
Spring集成Junit步骤
①导入spring集成Junit的坐标
②使用@Runwith注解替换原来的运行期
③使用@ContextConfiguration指定配置文件或配置类
④使用@Autowired注入需要测试的对象
⑤创建测试方法进行测试
三、Spring的AOP
1.Spring 的 AOP 简介
1.1 什么是 AOP
AOP 为 Aspect Oriented Programming 的缩写,意思为面向切面编程,是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。
AOP 是 OOP 的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。
1.2 AOP 的作用及其优势
- 作用:在程序运行期间,在不修改源码的情况下对方法进行功能增强
- 优势:减少重复代码,提高开发效率,并且便于维护
1.3 AOP 的底层实现
实际上,AOP 的底层是通过 Spring 提供的的动态代理技术实现的。在运行期间,Spring通过动态代理技术动态的生成代理对象,代理对象方法执行时进行增强功能的介入,在去调用目标对象的方法,从而完成功能的增强。
1.4 AOP 的动态代理技术
常用的动态代理技术
- JDK 代理 : 基于接口的动态代理技术
- cglib 代理:基于父类的动态代理技术
1.5 JDK 的动态代理
①目标类接口
package com.itheima.proxy.jdk;public interface TargetInterface {public void save();
}
②目标类
package com.itheima.proxy.jdk;public class Target implements TargetInterface {@Overridepublic void save() {System.out.println("save running");}
}
③动态代理代码,调用代理对象的方法测试
package com.itheima.proxy.jdk;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;public class ProxyTest {public static void main(String[] args) {// 创建目标对象Target target = new Target();// 获得增强对象Advice advice = new Advice();// 返回值是动态生成的代理对象TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(target.getClass().getClassLoader(), // 目标对象加载器target.getClass().getInterfaces(),//目标对象相同的接口字节码对象数组new InvocationHandler() {// 调用代理对象的任何方法,实质执行的都是invoke方法@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// 前置增强advice.before();Object invoke = method.invoke(target, args);// 执行目标方法// 后置增强advice.afterReturning();return invoke;}});// 调用代理对象的方法proxy.save();}
}
1.6 cglib 的动态代理
①目标类
package com.itheima.proxy.cjlib;public class Target {public void save() {System.out.println("save running.....");}
}
②动态代理代码,调用代理对象的方法测试
package com.itheima.proxy.cjlib;import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;import java.lang.reflect.Method;public class ProxyTest {public static void main(String[] args) {//目标对象final Target target = new Target();//增强对象final Advice advice = new Advice();//返回值 就是动态生成的代理对象 基于cglib//1、创建增强器Enhancer enhancer = new Enhancer();//2、设置父类(目标)enhancer.setSuperclass(Target.class);//3、设置回调enhancer.setCallback(new MethodInterceptor() {public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {advice.before(); //执行前置Object invoke = method.invoke(target, args);//执行目标advice.afterReturning(); //执行后置return invoke;}});//4、创建代理对象Target proxy = (Target) enhancer.create();proxy.save();}
}
1.7 AOP 相关概念
Spring 的 AOP 实现底层就是对上面的动态代理的代码进行了封装,封装后我们只需要对需要关注的部分进行代码编写,并通过配置的方式完成指定目标的方法增强。
在正式讲解 AOP 的操作之前,我们必须理解 AOP 的相关术语,常用的术语如下:
Target(目标对象):代理的目标对象。要被增强的对象。
Proxy (代理):一个类被 AOP 织入增强后,就产生一个结果代理类。
Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点。可以被增强的方法。
Java进阶:Spring相关推荐
- Java程序员进阶——Spring依赖注入原理分析
Spring依赖注入原理分析 下面谈谈Spring是如何实现反转模式IOC或依赖注入模式DI: 平时,我们需要生成一个对象,使用new语法,如一个类为A public class A{public v ...
- 视频教程-Java进阶高手课-Spring精讲精练-Java
[ [这里是图片001] Java进阶高手课-Spring精讲精练 中国科学技术大学硕士研究生,丹麦奥尔堡大学访问学者,先后就职于eBay.蚂蚁金服.SAP等国内外一线互联网公司,在Java后端开发. ...
- 《Java 进阶之路》 下--推荐书籍
真正想提升自己,我感觉最主要的是先把 JVM.并发.网络这三块知识点学会.学通,这三块是基础,后面所有的框架.中间件等相关的都是基于这三块知识点之上的.学完这三块知识点,可以快速的掌握其它的知识,新框 ...
- 《java 进阶之路》 上--推荐书籍
整整一月没有更新博客了,因为十月份和双十一新入手的6本技术相关的书,这个月看完了3本,后面的3本还得慢慢肯. 下面我就介绍下进阶高级工程师必须也是我自己都看的一些书和知识点. 1.深入理解Java虚拟 ...
- java resouce_深入了解 Java Resource Spring Resource
在Java中,为了从相对路径读取文件,经常会使用的方法便是: xxx.class.getResource(); xxx.class.getClassLoader().getResource(); 在S ...
- 超仪电子 java面试_全靠这份阿里大佬的“Java进阶面试手册”助我收获蚂蚁金服offer!...
都2021年了,你的工资涨了吗? 对于即将到来的金三银四跳槽涨薪季,我想很多小伙伴都已经摩拳擦掌了吧!当然,我猜也有很多小伙伴是下图的状态吧!毕竟面试一年比一年难[落泪] 不得不说现在面试确实很难,现 ...
- Java基础到Java进阶——Java小白的历练之路------从0到1,开卷!
Java小白的历练之路------从0到1 title: Java Essay date: 2022-09-07 08:58:32 tags: Java notes 写在前面: 免责声明:本笔记来源自 ...
- 阿里内部发布最新版Java进阶笔记,金九银十看这份文档就够了
大家都说程序员这个职业薪资高.待遇好,现在是程序员"跳槽"的黄金时期,你准备好了吗?有没有给自己定个小目标?是30K.40K,还是更高?短期内提高Java 核心能力最快.最有效的方 ...
- 【Java进阶营】Java是什么?Java的特点有哪些?
IT程序员现在几乎是薪资高,前景好的行业象征,无论是国内还是国外,IT行业的程序员.工程师,甚至连码农都要比其他行业的从业者的收入高很多!尤其是作为IT界的"常青树"Java,起薪 ...
- 抖音Java后端开挂,全靠这份啃了48天【Java进阶核心知识集+刷:25专题面试】
人人都想进大厂,当然我也不例外.早在春招的时候我就有向某某某大厂投岗了不少简历,可惜了,疫情期间都是远程面试,加上那时自身也有问题,导致屡投屡败.突然也意识到自己肚子里没啥货,问个啥都是卡卡卡卡,后期 ...
最新文章
- uninque()用法
- linux ping 连续,在SUN Solaris下连续ping的使用
- 华科博士 201 万,西安交大本科生 100 万!华为「天才少年」校招薪资曝光
- linux下的压缩与解压缩
- s5p4418 Android 4.4.2 驱动层 HAL层 服务层 应用层 开发流程记录(三 APP应用)
- 梦想中的网络安全和内部协作
- RedisTemplate和StringRedisTemplate的区别
- centos java 路径_CentOS JAVA安装及查看路径方法
- One Web MKey
- 2019年全国程序员统一考试,现在开始!
- DOS的古董美(未完待續)
- 基于python flask的网上商城源码 mysql数据库
- 网易数帆、云音乐、Intel、有赞最新大数据实践(PPT下载+视频回放)
- Button点击事件的五种写法
- 支付宝实现当面付扫描支付退款及退款查询
- SICP练习1.16
- 三次方分解因式重要公式
- gfs和hdfs文件系统的区别
- 用尽可能多的字数介绍Leaky ReLU激活函数
- 中国电子商务网经的盈利策略
热门文章
- 39.Linux 内核
- 防止用户直接访问url
- 《数学之美》—统计语言模型
- linux shell中$0,$?,$!等的特殊用法
- [C++]动态规划系列之币值最大化
- Sequence of methods in form and table in AX
- MongoDB 可视化管理工具 MongoCola-1.1.0 测试版发布
- NSArray的排序问题
- T-SQL多个小计+合计,分类汇总
- 我学习的自定义ASP.NET分页控件
- Java程序员进阶——Spring依赖注入原理分析