no2-spring核心基础

1.spring介绍

2.IOC和DI

分别解释ioc和di的概念，代码展示

ioc:控制反转，将bean的创建权由原来程序反转给第三方（spring）

di:依赖注入，某个bean想要完整的创建依赖于其他bean的注入

面试：ioc和di的关系

第一种观点：

ioc强调的是bean创建权的反转，而di强调的是bean的依赖关系，认为不是一回事。

第二种观点

ioc强调的是bean创建权的反转，而di强调的是通过注入的方式反转bean的创建权，认为是一回事。

2.1ioc控制反转实战xml方式

• 先引入jar,这里采用maven的方式

      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>5.2.5.RELEASE</version>
      </dependency>

      <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.13.2</version>
          <scope>test</scope>

      </dependency>

      <dependency>
          <groupId>org.projectlombok</groupId>
          <artifactId>lombok</artifactId>
          <version>1.18.16</version>

      </dependency>

• 编写applicationContext配置文件

 <bean class="com.springboot.dao.impl.UserInfoDaoImpl" id="userInfoDao">

    </bean>

建实体类，dao层类，test测试类就不赘述了。

2.2依赖注入过程说明

xml的方式

• 设值注入service

public class UserInfoServiceImpl implements UserInfoService {
    private UserInfoDao userInfoDao;


    public void setUserInfoDao(UserInfoDao userInfoDao) {
        this.userInfoDao = userInfoDao;
    }

    @Override
    public int addUser(UserInfo userInfo) {
        return userInfoDao.insertUser(null);
    }
}

• applicationContext.xml

    <bean class="com.springboot.dao.impl.UserInfoDaoImpl" id="userInfoDao"> </bean>
    <bean id="userInfoService" class="com.springboot.service.impl.UserInfoServiceImpl">
        <property name="userInfoDao" ref="userInfoDao"/>
    </bean>

注解的方式

这里把applicationContext.xml整个删掉

也有两种写法

• 第一种

配置类如下

@Configuration //applicationContext.xml
public class AppConfig {

    @Bean //<bean>
    public UserInfoDao  userInfoDao(){
        return  new UserInfoDaoImpl();
    }

    @Bean
    public UserInfoService userInfoService(){
        UserInfoService userInfoService = new UserInfoService();
        userInfoService.setUserInfoDao(userInfoDao());
        return userInfoService;
    }
}

测试类：

    @Test
    public void addUser() {
        ApplicationContext app = new AnnotationConfigApplicationContext(AppConfig.class);
        UserInfoService userInfoService = app.getBean(UserInfoService.class);
        userInfoService.addUserinfo();

    }

• 第二钟

配置类如下

@Configuration //applicationContext.xml
@ComponentScan(value = {"com.jf3q.service","com.jf3q.dao"})
public class AppConfig {
}

service和dao层对应加上注解和依赖注入

测试类不变。

这两种方式各自有各自的用处，比如mysql数据源放到bean的话就只能用第一种方式了，因为你不可能进jar包里加注解去。

pom文件

 <!--数据库-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.32</version>
        </dependency>

        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>

配置类

@Configuration //applicationContext.xml
@ComponentScan(value = {"com.jf3q.service","com.jf3q.dao"})
@PropertySource("classpath:datasource.properties")
public class AppConfig {

    @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(){
        BasicDataSource dataSource = new BasicDataSource();
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return  dataSource;
    }
}

2.3拆分spring配置

• xml方式拆分

• 配置类方式拆分

3.spring aop

1. 引入依赖

 <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>

3.1xml的方式

<aop:config>
   <aop:pointcut id="jp" expression="execution(* com.jf3q.service..*.*(..))"/>
   <aop:aspect ref="serviceLog">
     <aop:before method="before" pointcut-ref="jp" />
     <aop:after-returning method="afterReturning" pointcut-ref="jp" returning="result"/>
   </aop:aspect>

 </aop:config>

增强类：

@Log4j
public class UserServiceLog {
    public void before(JoinPoint jp){
        log.info("调用目标对象"+jp.getTarget()+"的方法："+jp.getSignature().getName()
        +"入参："+Arrays.toString(jp.getArgs()));

    }

    public void afterReturning(JoinPoint jp,Object result){
        log.info("调用对象：" + jp.getTarget()
                + "\n 方法" + jp.getSignature().getName() + "\n 返回值：" +result);
    }

}

3.2基于注解的方式

@Log4j
@Component
@Aspect
@EnableAspectJAutoProxy
public class UserServiceLog {
    @Pointcut("execution( * com.chract01.service..*.*(..))")
    public void point(){

    }
    @Before("point()")
    public void before(JoinPoint jp){
        log.info("调用目标对象"+jp.getTarget()+"的方法："+jp.getSignature().getName()
        +"入参："+Arrays.toString(jp.getArgs()));

    }
    @AfterReturning(value = "point()",returning = "result")
    public void afterReturning(JoinPoint jp,Object result){
        log.info("调用对象：" + jp.getTarget()
                + "\n 方法" + jp.getSignature().getName() + "\n 返回值：" +result);
    }

剩下的增强类型自己写