基于注解的IOC配置

用于创建对象的

它们的作用就和在xml配置文件中编写一个<bean>标签实现的功能一样
	 @Component
     作用:用把当前类对象存入spring容器
     属性：
     	value:用于指定bean的id。不写时，它的默认值为当前类目且首字母小写
   		@Controller,一般用于表现层
  		@Service，一般用于业务层
 		@Repository，一般用于持久层

用于注入数据的

 它们的作用就和在xml配置文件中编写一个<bean>标签中写一个<property>标签实现的功能一样的
  @Autowired
       作用：自动按照类型注入。只要容器中有唯一的bean对象类型和要注入的变量类型匹配，就可以注入成功
               		如果ioc容器中没有任何bean的类型和要注入的变量类型匹配，则报错
                  	如果ioc容器中有多个类型匹配时，会根据名称来查找。
          出现位置：
               可以是成员，也可以是方法
           细节：set和get方法不是必须的
  @Qualifier :
        作用：在按照类中注入的基础之上再按照名称注入。他在给类成员注入时不能单独使用。但是在给方法参数注入时可以
        属性:
              value,用于指定注入bean的id
   @Resource:
           作用：直接按照bean的id注入。它可以单独使用
            属性：
                   name:用于指定bean的id
       以上三个注入都只能注入其它bean类型的数据，而基本类型和String类型无法使用上述注解实现。
       另外，集合类型的注入只能通过XML来实现

    @Value
          作用:用于注入基本类型和String类型的数据
           属性：
              value:用于指定数据的值。它可以使用spring中SpEl(也就是spring的el 表达式)
                      SpEl 的写法：$(表达式）

用于改变作用范围的

   它们的作用就和在xml配置文件中编写一个<bean>标签中使用scop属性实现的功能一样的
   Scope
       作用:用于指定bean的作用范围
       属性：
           value:指定范围的取值。常用取值：singleton 、prototype
           不写的话默认单例

和生命周期相关的

   它们的作用就和在xml配置文件中编写一个<bean>标签中使用init-method和destroy-method的作用一样的
   @PreDestroy
       作用：用于指定销毁方法
   @PostConstruct
       作用:用于指定初始化方法

spring中的新注解

Configuration
   作用：指定该类是一个配置类，作用和bean.xml相等
ComponentScan
   作用：用于通过注解指定spring在创建容器时要扫描的包
   属性：
       value:他和basePackage的作用一样，都是用于指定创建容器时要扫描的包
               我们使用此注解就等同于在xml中配置了
               <context:component-scan base-package="mu.lin.hu"/>

Bean
   作用：用于把当前方法的返回值作为bean对象存入spring的ioc容器
   属性：
       name:用于指定Bean的id。当不写时，默认值是当前方法的名称
   细节:
       当我们使用注解配置方法时，如果方法有参数时，spring框架会去容器中查找有没有可用的对象。
       查找方式和Autowired注解的作用时一样
Import
   作用：用于导入其它配置类
 属性：
      value:用于指定其它配置类的字节码
               当我们使用Import的注解后，有Import注解的类就为父配置类，其它为子配置类
 PropertySource
       作用:用于指定properties文件的位置
       属性：
           value:指定文件的名称和路径。
           关键字：classpath，表示类路径下

一个完整的案例

package mu.lin.hu.dao;

import mu.lin.hu.domain.Account;

import java.util.List;

/**
 * 账户的持久层接口
 */
public interface IAccountDao {
    public List<Account> findAllAccount() ;

    public Account findById(Integer id) ;

    public void saveAccount(Account account) ;

    public void updateAccount(Account account) ;

    public void deleteAccount(Integer accountId);
}

package mu.lin.hu.dao.impl;

import mu.lin.hu.dao.IAccountDao;
import mu.lin.hu.domain.Account;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ArrayHandler;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import java.util.List;
@Repository("accountDao")
public class AccountDaoImpl implements IAccountDao {

    @Autowired
    private QueryRunner runner;

    public List<Account> findAllAccount() {
        List<Account> accountList=null;
        try {

            accountList= runner.query("select * from account",new BeanListHandler<Account>(Account.class));

        }catch (Exception e){
            e.printStackTrace();
        }
        return accountList;
    }

    public Account findById(Integer id) {
        Account account=null;
        try {
           account = runner.query("select id ,name,money from account where id=?",new BeanHandler<Account>(Account.class),id);
        }catch (Exception e){
            e.printStackTrace();
        }

        return account;
    }

    public void saveAccount(Account account) {

        try {
            runner.update("insert into account(name,money) values(?,?) ",account.getName(),account.getMoney());
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public void updateAccount(Account account) {
        try {
            runner.update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public void deleteAccount(Integer accountId) {
        try {
            runner.update("delete from  account where id=? ",accountId);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

package mu.lin.hu.domain;

import java.io.Serializable;

public class Account implements Serializable {
    private Integer id;
    private String name;
    private Float money;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Float getMoney() {
        return money;
    }

    public void setMoney(Float money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

package mu.lin.hu.service;

import mu.lin.hu.domain.Account;

import java.util.List;

public interface IAccountService {
    /**
     * 查询所有
     * @return
     */
    List<Account> findAllAccount();

    /**
     * 查询一个
     * @return
     */
    Account findById(Integer id);

    void saveAccount(Account account);

    void updateAccount(Account account);

    void deleteAccount(Integer accountId);
}

package mu.lin.hu.service.impl;

import mu.lin.hu.dao.IAccountDao;
import mu.lin.hu.domain.Account;
import mu.lin.hu.service.IAccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
@Service("accountService")
public class AccountServiceImpl implements IAccountService {
    @Autowired
    private IAccountDao accountDao;



    public List<Account> findAllAccount() {
        return accountDao.findAllAccount();
    }

    public Account findById(Integer id) {
        return accountDao.findById(id);
    }

    public void saveAccount(Account account) {
        accountDao.saveAccount(account);
    }

    public void updateAccount(Account account) {
        accountDao.updateAccount(account);
    }

    public void deleteAccount(Integer accountId) {
        accountDao.deleteAccount(accountId);
    }
}

package mu.lin.hu.config;


import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.apache.commons.dbutils.QueryRunner;
import org.springframework.context.annotation.*;

import javax.sql.DataSource;

/**
 * 该类是一个配置类
 * 作用和bean.xml相等
 * spring中的新注解
 * Configuration
 *      作用：指定该类是一个配置类
 *  ComponentScan
 *      作用：用于通过注解指定spring在创建容器时要扫描的包
 *      属性：
 *          value:他和basePackage的作用一样，都是用于指定创建容器时要扫描的包
 *                  我们使用此注解就等同于在xml中配置了
 *                  <context:component-scan base-package="mu.lin.hu"/>
 *
 *  Bean
 *      作用：用于把当前方法的返回值作为bean对象存入spring的ioc容器
 *      属性：
 *          name:用于指定Bean的id。当不写时，默认值是当前方法的名称
 *      细节:
 *          当我们使用注解配置方法时，如果方法有参数时，spring框架会去容器中查找有没有可用的对象。
 *          查找方式和Autowired注解的作用时一样
 *  Import
 *      作用：用于导入其它配置类
 *      属性：
 *          value:用于指定其它配置类的字节码
 *                  当我们使用Import的注解后，有Import注解的类就为父配置类，其它为子配置类
 *  PropertySource
 *          作用:用于指定properties文件的位置
 *          属性：
 *              value:指定文件的名称和路径。
 *              关键字：classpath，表示类路径下
 */
@Configuration
@ComponentScan(basePackages = "mu.lin.hu")
@Import({JdbcConfig.class})
public class SpringConfiguration {

    /**
     * 用于创建QueryRunner对象
     * @param dataSources
     * @return
     */
    @Bean(name = "runner")
    @Scope("prototype")
    public QueryRunner createQueryRunner(DataSource dataSources){
        return new QueryRunner(dataSources);
    }




}

package mu.lin.hu.config;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

import javax.sql.DataSource;
@PropertySource("classpath:jdbcConfig.properties")
public class JdbcConfig {
    @Value("${jdbc.Driver}")
    private String driverClass;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;
    /**
     * 创建数据源对象
     * @return
     */
    @Bean
    public DataSource createDataSource(){
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        try {
            dataSource.setDriverClass(driverClass);
        }catch (Exception e){
            e.printStackTrace();
        }

        dataSource.setJdbcUrl(url);
        dataSource.setUser(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}
配置文件的内容
jdbc.Driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/springtest
jdbc.username=root
jdbc.password=root

测试
package mu.lin.hu.test;

import mu.lin.hu.config.SpringConfiguration;
import mu.lin.hu.domain.Account;
import mu.lin.hu.service.IAccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

/**
 * 使用junit 单元测试
 * spring整合junit的配置
 *      1.导入spring整合junit的jar包 或坐标
 *      2.使用junit提供的一个注解把原有的main方法替换了，替换成spring提供的
 *         @Runwith
 *      3.告知spring的运行容器，spring和ioc创建是基于xml还是注解的。并且说明位置
 *          @ContextConfiguration
 *                      locations:指定xml文件的位置，加上classpath关键字，表示在类路径下
 *                      classes: 指定注解类所在地位置
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes =SpringConfiguration.class )
public class AccountServiceTest {
    @Autowired
    private IAccountService as;
    @Test
    public void testFindAll(){
        //ApplicationContext ac=new AnnotationConfigApplicationContext("mu.lin.hu");
        //ApplicationContext ac=new AnnotationConfigApplicationContext(SpringConfiguration.class);
       // IAccountService as=ac.getBean("accountService",IAccountService.class);
        List<Account> accounts=as.findAllAccount();
        for(Account account:accounts){
            System.out.println(account);
        }

    }
    @Test
    public void testFindone(){
        ApplicationContext ac=new AnnotationConfigApplicationContext(SpringConfiguration.class);
        IAccountService as=ac.getBean("accountService",IAccountService.class);
        Account account=as.findById(1);
        System.out.println(account);
    }
    @Test
    public void testSave(){
        Account account=new Account();
        account.setName("lin");
        account.setMoney(123.0f);
        ApplicationContext ac=new AnnotationConfigApplicationContext(SpringConfiguration.class);
        IAccountService as=ac.getBean("accountService",IAccountService.class);
        as.saveAccount(account);

    }
    @Test
    public void testUpdate(){
        ApplicationContext ac=new AnnotationConfigApplicationContext(SpringConfiguration.class);
        IAccountService as=ac.getBean("accountService",IAccountService.class);
        Account account=as.findById(4);
        account.setName("yong1");
        as.updateAccount(account);
    }
    @Test
    public void testdelete(){
        ApplicationContext ac=new AnnotationConfigApplicationContext(SpringConfiguration.class);
        IAccountService as=ac.getBean("accountService",IAccountService.class);
        as.deleteAccount(4);
    }
}

pom.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>mu.lin.hu</groupId>
    <artifactId>day02_eesy_04_accountannoioc_withoutXML</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.39</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>
    </dependencies>

</project>