Spring基本用法简述

Spring基本用法简述

SSM

S:SpringMVC

S:Spring

M:Mybatis（半自动的ORM实现）

SSH

S:Struts2

S:Spring

H:hibernate(全自动的ORM实现)

概述

1. Spring是一个开源的框架，是为了解决企业级应用开发的复杂性而设计的
2. Spring最根本的使命：全方位简化java开发
3. 核心思想：
   • IoC：控制反转，就是把依赖对象创建的控制权交给第三方（Spring容器）来管理
   • DI：依赖注入，组件之间的依赖关系，在程序运行期间吗，由第三方动态注入

使用

1. 添加spring依赖

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

2. 添加spring容器的配置类，并添加组件

   //表示其注解的类是一个配置类，用来配置spring容器的
   @Configuration
   public class AppConfig {
   
       //组件
       @Bean
       public DeptDao deptDao(){
           return new DeptDaoImpl();
       }
   
   }
   

3. 测试

   public class DeptDaoTest {
   
       @Test
       public void testInsert(){
           //创建一个容器，基于配置类
           ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
   
           //得到组件,根据接口类型（DeptDao），得到该接口的实现类
           DeptDao deptDao = applicationContext.getBean(DeptDao.class);
           //调用组件的业务方法
           deptDao.insert();
           //关闭容器
           ((AnnotationConfigApplicationContext)applicationContext).close();
       }
   
   }
   

4. 组件装配

   public class DeptServiceImpl implements DeptService {
       private DeptDao deptDao;
       //依赖注入
       public void setDeptDao(DeptDao deptDao) {
           this.deptDao = deptDao;
       }
   
       @Override
       public void insert() {
           //调用数据访问层实现添加功能
           deptDao.insert();
       }
   }
   

   属性注入

   @Configuration
   public class AppConfig {
   
       //组件
       @Bean
       public DeptDao deptDao(){
           return new OracleDeptDaoImpl();
       }
   
       @Bean
       public DeptService deptService(){
           DeptServiceImpl deptService = new DeptServiceImpl();
           //DI
           deptService.setDeptDao(deptDao());
           return deptService;
       }
   
   }
   

   测试

   public class DeptServiceTest {
       @Test
       public void testInsert(){
           //创建容器
           ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
           //得到业务逻辑组件
           DeptService deptService = applicationContext.getBean(DeptService.class);
   
           deptService.insert();
           //关闭容器
           ((AnnotationConfigApplicationContext)applicationContext).close();
       }
   }
   

5.组件扫描

• 在配置类上添加组件扫描注解

  @Configuration
  @ComponentScan(basePackages = {"com.dhee.dao","com.dhee.service"})
  public class AppConfig {
  

• 在需要成为组件的类上添加@Component注解

  @Configuration
  public class MySQLDeptDaoImpl implements DeptDao {
      @Override
      public void insert() {
          System.out.println("MYSQL添加部门成功");
      }
  }
  

6.自动装备

@Component
public class DeptServiceImpl implements DeptService {
    @Autowired
    @Qualifier("mySQLDeptDaoImpl")
    private DeptDao deptDao;

7.解决自动装配冲突

@Component
public class DeptServiceImpl implements DeptService {
    @Autowired
    @Qualifier("mySQLDeptDaoImpl")
    private DeptDao deptDao;

   

    @Override
    public void insert() {
        //调用数据访问层实现添加功能
        deptDao.insert();

    }
}

8.使用组件名得到组件

DeptDao deptDao = (DeptDao)applicationContext.getBean("mySQLDeptDaoImpl");

使用spring的测试模块

1. 导入依赖

   		<dependency>
               <groupId>org.springframework</groupId>
               <artifactId>spring-test</artifactId>
               <version>4.3.8.RELEASE</version>
           </dependency>
   

2. 测试

   @ContextConfiguration(classes = {AppConfig.class})
   //相当于测试框架（Junit）与Spring的一个接口
   @RunWith(SpringJUnit4ClassRunner.class)
   //当使用测试模块的时候，Spring会把测试类自动祖册到spring容器中，变为组件
   
   public class DeptTest {
       @Autowired
       @Qualifier("mySQLDeptDaoImpl")//使用名称得到组件
       private DeptDao deptDao;
   
       @Test
       public void testDeptDaoInset(){
           deptDao.insert();
       }
   }
   

AOP

1. 定义：面向切面编程，模块化横切关注点（把相同的代码加入到关注的方法上）
2. 到入jar包

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

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.7.3</version>
        </dependency>

3.定义一个类，实现切面功能

@Configuration
@EnableAspectJAutoProxy//开启切面自动代理
@Component
@Aspect//切面
public class AOPUtil {
}

4.在切面类中添加切入点方法

@Configuration
@EnableAspectJAutoProxy//开启切面自动代理
@Component
@Aspect//切面
public class AOPUtil {
    //切入点（切点）：加入相同代码的一组关注点（连接点）
    //切入点表达式：能够找到要加入代码的方法
    @Pointcut("execution(* com.dhee.dao.*.*(..))")
    public void pointcut(){

    }
}

5.在切面类中添加通知

@Configuration
@EnableAspectJAutoProxy//开启切面自动代理
@Component
@Aspect//切面
//当前类定义在aop包中，需要在组件扫描的时候能被扫描到
public class AOPUtil {
    //切入点（切点）：加入相同代码的一组关注点（连接点）
    //切入点表达式：能够找到要加入代码的方法
    @Pointcut("execution(* com.dhee.dao.*.*(..))")
    public void pointcut(){


    }

    //环绕通知:就是在方法（连接点）前后加入的代码
    @Around("pointcut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.nanoTime();
        //调用目标方法,得到方法的返回值
        Object object = joinPoint.proceed();

        long m = System.nanoTime() - startTime;
        System.out.println("该方法执行花费了：" + m + "脑秒" );

        return object;
    }
}

6.基本概念

• 连接点（joinPoint）：程序执行过程中的特定点（spring中只支持方法作为连接点）

• 通知（advice）：在特定连接点加入的代码（5种）

• 切入点（pointcut）：加入相同通知的一组连接点

• 切面（aspect）：通知与切入点的结合

7.前置通知：方法执行前加入代码

@Before("pointcut()")
    public void brfore(){
        SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("开始执行时间：" + f.format(new Date()));
    }

8.返回（后置）通知