我爱Java系列---【Spring基于全注解的 IOC 配置】

总结：

　　1. @Configuration：

　　　　作用：用于指定当前类是一个 spring 配置类，当创建容器时会从该类上加载注解。获取容器时需要使用
　　 　　　　  AnnotationApplicationContext(有@Configuration 注解的类.class)。
　　　　属性：
　　　　　　value:用于指定配置类的字节码

示例代码：
/**
* spring 的配置类，相当于 bean.xml 文件
* @Version 1.0
*/
@Configuration
public class SpringConfiguration {
}
注意：
我们已经把配置文件用类来代替了，但是如何配置创建容器时要扫描的包呢？
请看下一个注解。

 

　　　2. @ComponentScan

　　　　作用：
　　　　　　用于指定 spring 在初始化容器时要扫描的包。作用和在 spring 的 xml 配置文件中的：
　　　　　　<context:component-scan base-package="com.itheima"/>是一样的。
　　　　属性：
　　　　　　basePackages：用于指定要扫描的包。和该注解中的 value 属性作用一样。

示例代码：
/**
* spring 的配置类，相当于 bean.xml 文件
* @Version 1.0
*/
@Configuration
@ComponentScan("com.itheima")
public class SpringConfiguration {
}
注意：
我们已经配置好了要扫描的包，但是数据源和 QueryRuner 对象如何从配置文件中移除呢？
请看下一个注解。

　　3. @Bean

 　　　　作用：

　　　　　　该注解只能写在方法上，表明使用此方法创建一个对象，并且放入 spring 容器。
　　　　属性：
　　　　　　name：给当前@Bean 注解方法创建的对象指定一个名称(即 bean 的 id）。

示例代码：
/**
* 连接数据库的配置类
* @author 黑马程序员
* @Company 
* @Version 1.0
*/
public class JdbcConfig {
/**
* 创建一个数据源，并存入 spring 容器中
* @return
*/
@Bean(name="dataSource")
public DataSource createDataSource() {
try {
ComboPooledDataSource ds = new ComboPooledDataSource();
ds.setUser("root");
ds.setPassword("1234");
ds.setDriverClass("com.mysql.jdbc.Driver");
ds.setJdbcUrl("jdbc:mysql:///spring_day02");
return ds;
} catch (PropertyVetoException e) {
throw new RuntimeException(e);
}
}
/**
* 创建一个 QueryRunner，并且也存入 spring 容器中
* @param dataSource
* @return
*/
@Bean(name="runner")
@Scope("prototype")
public QueryRunner createQueryRunner(DataSource dataSource) {
return new QueryRunner(dataSource);
}
}
注意:
我们已经把数据源和 QueryRunner 从配置文件中移除了，此时可以删除 bean.xml 了。
但是由于没有了配置文件，创建数据源的配置又都写死在类中了。如何把它们配置出来呢？
请看下一个注解。

　　4 .@PropertySource

　　作用：
　　　　用于加载.properties 文件中的配置。例如我们配置数据源时，可以把连接数据库的信息写到
　　　　properties 配置文件中，就可以使用此注解指定 properties 配置文件的位置。
　　属性：
　　　　value[]：用于指定 properties 文件位置。如果是在类路径下，需要写上 classpath:

示例代码：
配置：
/**
* 连接数据库的配置类
* @Version 1.0
*/
@PropertySource("classpath:jdbcConfig.properties")
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;
/**
* 创建一个数据源，并存入 spring 容器中
* @return
*/
@Bean(name="dataSource")
public DataSource createDataSource() {
try {
ComboPooledDataSource ds = new ComboPooledDataSource();
ds.setDriverClass(driver);
ds.setJdbcUrl(url);
ds.setUser(username);
ds.setPassword(password);
return ds;
} catch (PropertyVetoException e) {
throw new RuntimeException(e);
}
}
}
jdbc.properties 文件：
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_day02
jdbc.username=root
jdbc.password=1234
注意：
此时我们已经有了两个配置类，但是他们还没有关系。如何建立他们的关系呢？
请看下一个注解。

　　5 .@Import

　　　　作用：
　　　　　　用于导入其他配置类，在引入其他配置类时，可以不用再写@Configuration 注解。当然，写上也没问
　　　　　　题。
　　　　属性：
　　　　　　value[]：用于指定其他配置类的字节码。

 

示例代码：
@Configuration
@ComponentScan(basePackages = "com.itheima.spring")
@Import({ JdbcConfig.class})
public class SpringConfiguration {
}
@Configuration//写不写都行
@PropertySource("classpath:jdbc.properties")
public class JdbcConfig{
}
注意：
我们已经把要配置的都配置好了，但是新的问题产生了，由于没有配置文件了，如何获取容器呢？
请看下一小节。

 

　　6 .通过注解获取容器　

ApplicationContext ac = 
new AnnotationConfigApplicationContext(SpringConfiguration.class);

 

　　7.工程结构图

 

下面是案例演示：

1.创建 maven 工程并导入坐标

<dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>

    <!--spring单元测试-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>5.0.2.RELEASE</version>
    </dependency>

    <!-- spring框架 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.0.2.RELEASE</version>
    </dependency>

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

    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.26</version>
    </dependency>

    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.0.9</version>
    </dependency>
  </dependencies>

2.创建数据库和编写实体类

public class Account {

  private long id;
  private String name;
  private String password;
  private long money;


  public long getId() {
    return id;
  }

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


  public String getName() {
    return name;
  }

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


  public String getPassword() {
    return password;
  }

  public void setPassword(String password) {
    this.password = password;
  }


  public long getMoney() {
    return money;
  }

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

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

 

3.使用注解配置持久层

@Component("accountDao")
public  class AccountDaoImpl implements AccountDao {
    @Autowired
    private QueryRunner queryRunner;


    //1.增加账户
    public int save(Account account){
        String sql ="insert into account values (null,?,?,?) ";
        try {
         return   queryRunner.update(sql,account.getName(),account.getPassword(),account.getMoney());
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    //2.根据id查询账户信息
    @Override
    public Account findById(int id) {
        String sql ="select * from account where id=?";
        try {
            return queryRunner.query(sql,new BeanHandler<>(Account.class),id);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

4.使用注解配置业务层

@Service
public class AccountServiceImpl implements AccountService {
    @Resource(name="accountDao")
    private AccountDao accountDao;


    //1.增加账户
    @Override
    public int save(Account account) {

       return accountDao.save(account);
    }

    //2.根据id查询账户
    @Override
    public Account findById(int id) {
        return accountDao.findById(id);
    }
}

5.创建并编写配置类

//主配置文件
@ComponentScan({"com.itheima.service","com.itheima.dao"})
@Import(DaoConfig.class)
public class Config {

}

 1//子配置文件
 @PropertySource("classpath:db.properties")
public class DaoConfig {
    @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 QueryRunner getQueryRunner(DataSource dataSource) {
        QueryRunner queryRunner = new QueryRunner(dataSource);
        return queryRunner;
    }

    @Bean

    public DataSource getDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}

#db.properties文件
jdbc.url=jdbc:mysql:///heima?characterEncoding=utf-8
jdbc.driver=com.mysql.jdbc.Driver
jdbc.username=root
jdbc.password=root

6.测试类

public class AppTest {


    @Test
    public void test() {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
        AccountService accountService = context.getBean(AccountService.class);

        Account user = accountService.findById(2);
        System.out.println(user);

    }
}