Spring Day02笔记

注解开发：

在实体类上用@Component("name"),Spring建议对于业务层用@Service，对于数据层用@Repository，表现层用@Controller。功能一样，只是便于见名知意。默认单例，@Scope("prototype")设置为非单例。

//如果不指定名称的话，那么获取对象时要用类型获取ctx.getBean(UserService.class)
@Component("UserService")
public class UserServiceImpl implements UserService {}

xml文件中就不需要，声明对应的标签了，但需要设置包扫描

这样做了后，xml配置文件中只剩下一点内容了。

可以用配置类来替代xml配置文件。用@Configuration

package com.supersql.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration    //替代xml配置文件
@ComponentScan("com.supersql")    //替代配置文件的包扫描
public class SpringConfig {
    @PostConstruct    //生命周期
    public void init(){}
    @PreDestory
    public void destory(){}
}

没有了配置文件，之前用ClassPathXMLApplicationContext获取bean容器已经不顶用了，改用AnnotationConfigApplicationContext获取容器对象：

ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class)

如果此时A类依赖的B类也在Spring的管理范围内(也用了@Component注解，且被扫到)，那么可用@AutoWired自动装配，此为引用类型注入

package com.supersql.service.Impl;

import com.supersql.dao.UserDao;
import com.supersql.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService {
    // private UserDao userDao = new UserDaoImpl();

    //注意不需要像xml配置文件中一样依赖setter或者构造器注入，用的暴力反射。默认按类型装配
    //用@Qualifier("beanName"),指定名称装配
    @Autowired    //此处自动装配的是UserDaoImpl
    private UserDao userDao;
    @Override
    public void show() {
        userDao.select();
        System.out.println("service执行。。。");
    }
}

简单类型用@Value注入(简单类型直接赋值给变量不就好了吗，用@Value干嘛？？？可以配合属性占位符读取properties文件，在SpringConfig配置类中使用@PropertySource加载properties文件)。注意不可使用通配符，多个文件用数组的形式写。

@Configuration
@ComponentScan("com.supersql")
@PropertySource("jdbc.properties")
public class SpringConfig {
}

@Service
public class UserServiceImpl implements UserService {
    @Value("${jdbc.url}")
    private String url;
    @Override
    public void show() {
        System.out.println(url);
    }
}

那对于第三方bean该怎么管理呢，不是我们写的在哪里加@Component注解呢？@Bean配置的对象，如果想注入引用类型，为方法设置形参即可。

package com.supersql.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;

import javax.sql.DataSource;

public class JdbcConfig {
    //1.定义一个方法获得要管理的对象
    //2.将方法的返回值定义次bean
    //3.在SpringConfig里面import，或者直接在这个类上用@Configration
    @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("dataSource")
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(Driver);
        ds.setUrl(url);
        ds.setUsername(username);
        ds.setPassword(password);
        return ds;
    }
}

package com.supersql.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.PropertySource;

@Configuration
@ComponentScan("com.supersql")
@PropertySource("jdbc.properties")
@Import(JdbcConfig.class)
public class SpringConfig {
}

public static void main(String[] args) {
    AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
    DataSource dataSource = (DataSource) ctx.getBean("dataSource");
    System.out.println(dataSource);
}

整合Mybatis:

除了mybatis、druid、jdbc、spring-context这类jar包，还需要以下包



    org.springframework
    spring-jdbc
    5.2.10.RELEASE




    org.mybatis
    mybatis-spring
    1.3.0

用Mybatis的配置类替代xml配置文件，在SpringConfig处@Import，使其返回SqlSessionFactory对象纳入Spring的管理，由于mybatis的配置太多了，于是官方就提供了SqlSessionFactoryBean对象，快速创建对象。

package com.supersql.config;


import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;

import javax.sql.DataSource;

public class MyBatisConfig {
    @Bean
    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource){
        //创建sqlsessionFactoryBean对象
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        //设置数据源对象,DataSource是之前封装的druid，自动装配
        ssfb.setDataSource(dataSource);
        //设置类型别名
        ssfb.setTypeAliasesPackage("com.supersql");
        return ssfb;
    }
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        //创建映射关系
        msc.setBasePackage("com.supersql.dao");
        return msc;
    }
}

注意要添加@Bean注解啊，不然不能自动装配！！！

Spring整合JUnit：

junit
    junit
    4.13
    test



    org.springframework
    spring-test
    5.2.10.RELEASE

import com.supersql.config.SpringConfig;
import com.supersql.dao.UserDao;
import com.supersql.domain.Weapon;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class) //加载专用类运行器
@ContextConfiguration(classes = SpringConfig.class) //加载Spring环境
public class Test {
    @Autowired
    private UserDao userDao;

    @org.junit.Test
    public void test(){
        Weapon select = userDao.select();
        System.out.println(select);

    }
}

AOP：aspect oriented programming，面向切面编程。在不惊动原始设计的基础上进行功能增强。无入侵式编程。

1.aop的包在spring-context下，所以只需要导入aspectj包


    org.aspectj
    aspectjweaver
    1.9.4

2.抽取公共方法定义切入点，@Aspect,@Pointcut,@Before

package com.supersql.aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Component
@Aspect //告诉Spring这是AOP
public class MyAdvice {
    //定义切入点
    @Pointcut("execution(void com.supersql.dao.UserDaoImpl.delete())")
    public void pt(){};

    //绑定切入点和通知
    @Before("pt()")
    //定义通知
    public void method(){
        System.out.println("方法执行！！");
    }
}

3.SpringConfig.class里面

@EnableAspectJAutoProxy //启用@Aspect

注意这里一定要用父类型，不然代理报错

public static void main(String[] args) {
    ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
    UserDao userDaoImpl =(UserDao) ctx.getBean("UserDaoImpl");
    userDaoImpl.delete();
}

com.sun.proxy.$Proxy22 cannot be cast to com.supersql.dao.UserDaoImpl
//Junit中，自动装配，然后测试，报错
Bean named 'UserDaoImpl' is expected to be of type 'com.supersql.dao.UserDaoImpl' but was actually of type 'com.sun.proxy.$Proxy30'

AOP工作流程：1.Spring容器启动。2.读取所有配置并使用的切入点。3.初始化bean，判定bean中的方法是否匹配到任意切入点。4.匹配失败就创建对象。5.匹配成功就创建原始对象的代理对象，然后走的就是代理的那套东西。

切入点表达式：

*：表示匹配单个独立的任意符号，可独立出现，也可作为前缀后缀匹配符

execution(* com.supersql.*.UserService.find*(*))

..：表示匹配多个连续任意的符号

execution(User com..UserService.findById(..))

+：专用与匹配子类型

execution(* *..*Service+.*(..))

AOP通知类型: @Before()前置通知，@After()后置通知，异常也执行。

注意ProceedingJoinPoint仅用于@Around环绕通知，其他类型用JoinPoint

@Pointcut("execution(void com.supersql.dao.UserDao.delete(..))")
public void pt(){};

@Around("pt()")
    public Object method(ProceedingJoinPoint pjp) throws Throwable {
    System.out.println("前置方法执行！！");
    //获取参数列表
    Object[] args = pjp.getArgs();
    //执行原始方法
    Object ret = pjp.proceed();
    //Object ret = pjp.proceed(args);
    Signature signature = pjp.getSignature();
    //获取原始方法名
    String methodName = signature.getName();
    System.out.println(methodName);
    System.out.println("后置方法执行！！");
    return ret;
}

@AfterReturning,返回后通知。原始方法成功执行后执行，异常不执行。

@afterThrowing,抛异常后执行。

Spring Day02笔记

Java相关栏目本月热门文章