学完Spring之后是SpringMVC
学习Spring过程的笔记，没事得常回来看看0.0
使用@Component定义bean
@Component("bookDao")
public class BookDaoImpl implements BookDao {
public void save() {
System.out.println("book dao save ...");
}
}核心配置文件中通过组件扫描加载bean
<context:component-scan base-package="com.itheima"/>Spring提供@Component注解的三个衍生注解
1.@Controller:用于表现层bean定义
2.@Service：用于业务层bean定于
@Service
public class BookServiceImpl implements BookService {}3.@Repository：用于数据层bean定义
@Repository
public class BookDaoImpl implements BookDao {}Spring3.0开启了 纯注解开发模式，使用java类替代配置文件，开启了Spring快速开发通道
Java类代替Spring核心配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
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
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<context:component-scan base-package="com.itheima"/>
</beans>以上applicationContext.xml文件将会由以下SpringConfig.java文件代替
@Configuration
@ComponentScan("com.itheima")
public class SpringConfig{}@Configuration注解用于设定当前类为配置类
@ComponentScan注解用于设定扫描路径，此注解只能添加一次，多个数据用数组格式
@ComponentScan({"com.itheima.service","com.itheima.dao"})读取Spring核心配置文件初始化容器对象切换为读取Java配置类初始化容器对象
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);使用@Scope定义bean作用范围
使用@PostConstruct、@PreDestroy定义生命周期
@Repository
//@Scope设置bean的作用范围
@Scope("singleton")
public class BookDaoImpl implements BookDao {
public void save() {
System.out.println("book dao save ...");
}
@PostConstruct
public void init(){
System.out.println("book dao init ...");
}
@PreDestroy
public void destrop() {
System.out.println("book dao destroy...");
}
}使用@Autowired注解开启自动装配模式（按类型）
使用@Qualifier注解开启指定名称装配bean
@Service
public class BookServiceImpl implements BookService {
@Autowired
@Qualifier("bookDao2")
private BookDao bookDao;
}注意：自动装配基于反射设计创建对象并暴力反射对应属性为私有属性初始化数据，因此无需提供setter方法。
注意：自动装配建议使用无参构造方法创建对象（默认），如果不提供对应构造方法，请提供唯一的构造方法。
注意：@Qualifier注解无法单独使用，必须配合@Autowired注解使用
使用@Value实现简单类型注入
@Repository("bookDao")
public class BookDaoImpl2 implements BookDao {
@Value("szc")
private String name;
}使用@PropertySource注解加载properties文件
@Configuration
@ComponentScan("com.itheima")
@PropertySource({"classpath:jdbc.properties"})
public class SpringConfig {
}注意：路径仅支持单一文件配置，多文件使用数组格式配置，不允许使用通配符*
使用@Bean配置地方三方bean
@Configuration
public class SpringConfig{
@Bean
public DataSource dataSource(){
DruidDataSource ds = new DruidDataSource();
ds.setDriverClassName("com.mysql.jdbc.Driver");
ds.setUrl("jdbc:mysql//localhost:3306/spring_db");
ds.setUsername("root");
ds.setPassword("155931");
return ds;
}
}将独立的配置类加入核心配置
方式一:导入式
public class JdbcConfig {
//1.定义一个方法获得要管理的对象
//2.添加@Bean，表示当前方法的返回值是一个bean
@Bean
public DataSource dataSource(){
DruidDataSource ds = new DruidDataSource();
ds.setDriverClassName("com.mysql.jdbc.Driver");
ds.setUrl("jdbc:mysql//localhost:3306/spring_db");
ds.setUsername("root");
ds.setPassword("155931");
return ds;
}
}使用@Import注解手动加入配置类到核心配置，此注解只能添加一次，多个数据用数组格式
@Configuration
@Import(JdbcConfig.class)
public class SpringConfig {
}方式二：扫描式（不推荐）
@Configuration
public class JdbcConfig {
//1.定义一个方法获得要管理的对象
//2.添加@Bean，表示当前方法的返回值是一个bean
@Bean
public DataSource dataSource(){
DruidDataSource ds = new DruidDataSource();
ds.setDriverClassName("com.mysql.jdbc.Driver");
ds.setUrl("jdbc:mysql//localhost:3306/spring_db");
ds.setUsername("root");
ds.setPassword("155931");
return ds;
}
}使用@ComponentScan注解扫描类所在的包，加载对应的配置类信息
@Configuration
@Import("com.itheima.config")
public class SpringConfig {
}
简单类型依赖注入
public class JdbcConfig {
@Value("com.mysql.jdbc.Driver")
private String driver;
@Value("jdbc:mysql//localhost:3306/spring_db")
private String url;
@Value("root")
private String username;
@Value("155931")
private String password;
//1.定义一个方法获得要管理的对象
//2.添加@Bean，表示当前方法的返回值是一个bean
@Bean
public DataSource dataSource() {
DruidDataSource ds = new DruidDataSource();
ds.setDriverClassName(driver);
ds.setUrl(url);
ds.setUsername(username);
ds.setPassword(password);
return ds;
}
}引用类型依赖注入
@Bean
public DataSource dataSource(BookService bookService) {
System.out.println(bookService);
DruidDataSource ds = new DruidDataSource();
//属性设置
return ds;
}引用类型注入只需要为bean定义方法设置形参即可，容器会根据对象自动装配对象
需另外导入以下两个包
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.2.10.RELEASE</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>1.3.0</version> </dependency>
将以下代码转化成如下
<typeAliases>
<package name="com.itheima.domain"/>
</typeAliases>
<environments default="mysql">
<environment id="mysql">
<transactionManager type="JDBC"></transactionManager>
<dataSource type="POOLED">
<property name="driver" 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>
</dataSource>
</environment>
</environments> @Bean
public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource) {
SqlSessionFactoryBean ssfb= new SqlSessionFactoryBean();
ssfb.setTypeAliasesPackage("com.itheima.domain");
ssfb.setDataSource(dataSource);
return ssfb;
}SqlSession生成的一系列操作由SqlSessionFactoryBean解决
// 1. 创建SqlSessionFactoryBuilder对象
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
// 2. 加载SqlMapConfig.xml配置文件
InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml.bak");
// 3. 创建SqlSessionFactory对象
SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
// 4. 获取SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();这里的DataSurce 会自动生成 因为在JdbcConfig.class文件中已经生成了bean
public class JdbcConfig {
@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
public DataSource dataSource(){
DruidDataSource ds = new DruidDataSource();
ds.setDriverClassName(driver);
ds.setUrl(url);
ds.setUsername(userName);
ds.setPassword(password);
return ds;
}
}<mappers>
<package name="com.itheima.dao"></package>
</mappers> @Bean
public MapperScannerConfigurer mapperScannerConfigurer() {
MapperScannerConfigurer msc = new MapperScannerConfigurer();
msc.setBasePackage("com.itheima.dao");
return msc;
}需另外导入以下两个包
<dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope>test</scope> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>Spring-test</artifactId> <version>5.2.10.RELEASE</version> </dependency>
使用Spring整合Junit专用的类加载器
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {
@Autowired
private AccountService accountService;
@Test
public void testFindById(){
System.out.println(accountService.findById(1));
}
}注意前两行注释 ，需要测试什么对象 注入之后自动打包即可
AOP（Aspect Oriented Programming）面向切面编程，一种编程范式，指导开发者如何组织程序结构。Spring理念是无入侵式。
在不惊动原始设计的基础上进行功能增强。
1.导入包，Spring包导入会自动导入AOP
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.2.10.RELEASE</version> </dependency> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.4</version> </dependency>
2. 定义dao接口与实现类
public interface BookDao {
public void save();
public void update();
}@Repository
public class BookDaoImpl implements BookDao {
public void save() {
System.out.println(System.currentTimeMillis());
System.out.println("book dao save ...");
}
public void update(){
System.out.println("book dao update ...");
}
}
3.定义通知类，制作通知
public class MyAdvice {
public void method(){
System.out.println(System.currentTimeMillis());
}
}4.定义切入点
public class MyAdvice {
@Pointcut("execution(void com.itheima.dao.BookDao.update())")
private void pt(){}
}说明：切入点定义依托一个不具有实际意义的方法进行，即无参数，无返回值，方法体无实际逻辑
5.绑定切入点与通知关系，并指定通知添加到原始连接点的具体执行位置
public class MyAdvice {
@Pointcut("execution(void com.itheima.dao.BookDao.update())")
private void pt(){}
@Before("pt()")
public void method(){
System.out.println(System.currentTimeMillis());
}
}
6.定义通知类受Spring容器管理，并定义当前类为切面类
@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(void com.itheima.dao.BookDao.update())")
private void pt(){}
@Before("pt()")
public void method(){
System.out.println(System.currentTimeMillis());
}
}
7.开启Spring对AOP注解驱动支持
@Configuration
@ComponentScan("com.itheima")
@EnableAspectJAutoProxy//存在注解开发的AOP
public class SpringConfig {
}
1.Spring容器启动
2.读取所有切面配置中的切入点
3.初始化bean，判定bean对应的类中的方法是否匹配到任意切入点
匹配失败，创建对象
匹配成功，创建原始对象（目标对象）的代理对象
4.获取bean执行方法
获取bean，调用方法并执行，完成操作
获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作。
目标对象（Target）：原始功能去掉共性功能对应的类产生的对象，这种对象是无法直接完成最终工作的。
代理（Proxy）：目标对象无法直接玩成工作，需要对其进行功能回填，通过原始对象的代理对象实现。
切入点：要进行增强的方法
切入点表达式：要进行增强的方法的描述方式
1.执行com.itheima.dao包下的BookDao接口中的无参数update方法
execution(void.com.itheima.dao.BookDao.update())2.执行com.itheima.dao.impl包下的BookDaoImpl类中的无参数update方法
execution(void com.itheima.dao.impl.BookDaoImpl.update())动作关键词（访问修饰符 返回值 包名.类/接口名.方法名（参数）异常名）
execution(public User com.itheima.service.UserService.findById(int))
可以使用通配符描述切入点，快速描述
AOP通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理位置。
前置通知、后置通知、环绕通知（重点）、返回后通知（了解）、抛出异常后通知（了解）
@Component
@Aspect
public class ProjectAdvice {
//匹配业务层的所有方法
@Pointcut("execution(* com.itheima.service.*Service.*(..))")
private void servicePt(){}
@Around("ProjectAdvice.servicePt()")
public void runSpeed(ProceedingJoinPoint pjp) throws Throwable {
Signature signature = pjp.getSignature();
String declaringTypeName = signature.getDeclaringTypeName();
String name = signature.getName();
Long start = System.currentTimeMillis();
for(int i = 0; i <10000; i++){
pjp.proceed();
}
long end = System.currentTimeMillis();
System.out.println("万次执行:"+declaringTypeName+"."+name+"------>"+(end-start));
}
}
JoinPoint对象描述了连接点方法的运行状态，可以获取到原始方法的调用参数
@Before("pt()")
public void before(JoinPoint jp) {
Object[] args = jp.getArgs();
System.out.println(Arrays.toString(args));
}ProceedJointPoint是JoinPoint的子类，专用于环绕通知，可以实现对原始方法的调用
@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
Object[] args = pjp.getArgs();
System.out.println(Arrays.toString(args));
Object ret = pjp.proceed(args);
return ret;
}设置返回后通知获取原始方法的返回值
要求returning属性值必须与方法形参名相同
@AfterReturning(value = "pt()",returning = "ret")
public void afterReturning(JoinPoint jp,String ret) {
System.out.println("afterReturning advice ..."+ret);
}抛出异常后通知可以获取切入点方法中出现的异常信息，使用形参可以接受对应的异常对象
throwing的属性值必须与方法中的形参名相同
@AfterThrowing(value = "pt()",throwing = "t")
public void afterThrowing(Throwable t) {
System.out.println("afterThrowing advice ..."+t);
}
@Around("DataAdvice.servicePt()")
public Object trimStr(ProceedingJoinPoint pjp) throws Throwable {
Object[] args = pjp.getArgs();
for(int i = 0; i < args.length;i++){
//判断参数是不是字符串
if(args[i].getClass().equals(String.class)){
args[i]=args[i].toString().trim();
}
}
Object ret = pjp.proceed(args);
return ret;
}事务作用：再数据层保障一系列的数据库操作同成功同失败
Spring事务作用：在数据层或业务层保障一系列的数据库操作同成功同失败
1.在业务层接口上添加Spring事务管理
//配置当前接口方法具有事务
@Transactional
public void transfer(String out,String in ,Double money) ;
}注意：Sring注解式事务通常添加在业务层接口中而不会添加到业务层实现类中，降低耦合，
注解式事务可以添加到业务方法上表示当前方法开启事务，也可以添加到接口上表示当前接口所有方法开启事务
2.设置事务管理器
在JDBC配置中添加如下
//配置事务管理器
@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource){
DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
transactionManager.setDataSource(dataSource);
return transactionManager;
}注意：事务管理器根据实现技术进行选择Mybatis框架使用的是JDBC事务
3.开启注解式事务驱动@EnableTransactionManagement
@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
//开启注解式事务驱动
@EnableTransactionManagement
public class SpringConfig {
}
1.在业务层接口上添加Spring事务，设置事务传播行为REQUIRES_NEW（需要新事务）
也可以在该接口的实现类中的方法之上添加
public interface LogService {
@Transactional(propagation = Propagation.REQUIRES_NEW)
void log(String out, String in, Double money);
}
