第一章、注解与包扫描

1. 注解的作用

　　和 XML 配置文件一样，注解本身并不能执行，注解本身仅仅只是做一个标记，具体的功能是框架检测到注解标记的位置，然后针对这个位置按照注解标记的功能来执行具体操作。

　　本质上：所有一切的操作都是Java代码来完成的，XML和注解只是告诉框架中的Java代码如何执行。

　　注意：Spring 为了知道程序员在哪些地方标记了什么注解，就需要通过扫描的方式，来进行检测。然后根据注解进行后续操作。

2. 包扫描

　　（1）在xml文件中配置包扫描

　　　　引入schema约束：先引入命名空间，约束文件的位置（自动引入）

　　　　<context:component-scan> 主键扫描器

　　　　　　属性base-package：指定扫描的包

　　　　<context:component-scan base-package = "com.atguigu"/>

　　　　

　　（2）@Component：加在类上，将该类注入IOC容器

　　　　　　属性：value就是这个对象的id值配置，默认是就是类名，首字母小写

　　　　等价于：<bean class="com.atguigu.ioc.CommonComponent" id="commonComponent"/>

　　　　创建类：

　　　　@Controller：添加在表现层下

　　　　@Service：添加在业务层中

　　　　@Repository：添加在持久层

 

 

@Component(value = "myComponent1")
public class CommonComponent {
}

　　　　测试：

　　@Test
    //测试注解开发，通过id获取对象
    public void testGetBeanId(){
        Object commonComponent = context.getBean("myComponent1");
        System.out.println("commonComponent = " + commonComponent);
    }

 第二章、SpringIOC实现数据表操作（全配置文件）

1. 导入依赖

<!--导入jar包-->
  <dependencies>
    <!--
        添加spring框架的jar
        context:上下文，框架核心包
    -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.6.RELEASE</version>
    </dependency>
    <!--mysql-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.46</version>
    </dependency>
    <!--junit-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
    </dependency>
    <!--druid工具包-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.6</version>
    </dependency>
    <!--DBUtils-->
    <dependency>
      <groupId>commons-dbutils</groupId>
      <artifactId>commons-dbutils</artifactId>
      <version>1.6</version>
    </dependency>
    <!--lombook包-->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.12</version>
      <scope>provided</scope>
    </dependency>

    <!--添加日志jar-->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.2</version>
        <!--编译插件,配置信息-->
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
          <encoding>utf-8</encoding>
        </configuration>
      </plugin>
    </plugins>
  </build>

2. 创建dao层、service层、pojo包

　　（1）dao层

public interface AccountDao {
    public void saveAccount(Account account);
}

public class AccountDaoImpl implements AccountDao{
    //使用持久层QueryRUnner对象，对象已经放在IOC容器，注入进来
    private QueryRunner qr;

    public void setQr(QueryRunner qr) {
        this.qr = qr;
    }

    @Override
    public void saveAccount(Account account) {
        String sql = "insert into account values(?,?,?)";
        Object[] params = {account.getId(),account.getName(),account.getMoney()};
        try {
            qr.update(sql,params);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

　　（2）service层

public interface AccountService {
    public void saveAccount(Account account);
}

public class AccountServiceImpl implements AccountService {
    private AccountDao accountDao;
    
    public AccountServiceImpl(AccountDao accountDao) {
        this.accountDao = accountDao;
    }
    
    @Override
    public void saveAccount(Account account) {
        accountDao.saveAccount(account);
    }
}

　　（3）pojo层

@Data
public class Account {
    private Integer id;
    private String name;
    private double money;
}

3. 创建applicationContext.xml文件

　　（1）配置DataSource：

　　　　　　druid配置：DruidDataSource ——> 原始写法：DruidDataSourceFactory.createDataSource(properties)

　　　　　　c3p0配置：CombopooledDatasource ——> 原始写法：new CombopooledDataSource()

 <bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
        <!--DruidDataSource 对象使用set方法注入，数据库连接信息-->
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf8&amp;useSSL=false"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

 

<bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf8&amp;useSSL=false"/>
        <property name="password" value="root"/>
        <property name="user" value="root"/>
    </bean>

　　（2）配置QueryRunner对象

<!--
        配置QueryRunner对象
        private QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
    -->
    <bean class="org.apache.commons.dbutils.QueryRunner" id="queryRunner">
        <!--注入对象QueryRunner，构造方法注入，注入德鲁伊连接池-->
        <constructor-arg name="ds" ref="dataSource"/>
    </bean>

　　（3）配置Dao层、Service层实现类

<!--持久层对象，放在Spring的IOC容器中-->
    <bean class="com.atguigu.dao.AccountDaoImpl" id="accountDao">
        <!--set方法，注入QueryRunner对象-->
        <property name="qr" ref="queryRunner"/>
    </bean>
    <!--业务层对象，放在Spring的IOC容器中-->
    <bean class="com.atguigu.service.AccountServiceImpl" id="accountService">
        <!--构造方法，注入AccountDao对象-->
        <constructor-arg name="accountDao" ref="accountDao"/>
    </bean>

　　（4）测试

public class MainTest {
    private ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    @Test
    //测试IOC操作数据库
    public void testIOCSaveAccount(){
        //获取业务层对象
        AccountService accountService = context.getBean(AccountService.class);
        /*
            创建账户对象，存储数据
            Web开发，数据表单提交，封装数据
        * */
        Account account = new Account();
        account.setName("jack");
        account.setMoney(1000D);
        accountService.saveAccount(account);
    }
}

第三章、SpringAnnotationIOC实现数据表操作（半XML半注解）

　　整体内容除了dao层、service层对象注入SpringIOC容器中的配置改写为注解的形式外，没有其他位置的变动

　　（1）配置依赖，配置maven编译环境（maven-compile-plugin）

　　（2）创建applicationContext.xml

　　　　　　（1）将dao层、service层对象注入SpringIOC容器中的配置改写为注解的形式

　　　　　　@Autowired：自动装配对象，对象具有唯一性

　　　　　　@Qualifier：多个接口实现类，挑选一个合格对象进行装配，

　　　　　　　　　　注解属性 value 配置的是对象id唯一标识，与@AutoWired联合使用

　　　　　　@Resource 实现对象装配,JDK提供，不是Spring框架的注解

　　　　　　　　　　注解属性：name = 配置对象的唯一id值，@Resource = @Autowired + @Qualifier

　　　　　　（2）配置包扫描

　　　　　　（3）配置DataSource

　　　　　　（4）配置QueryRunner

　　（3）编写测试类

第四章、纯注解方式操作数据表

1.  创建配置文件类SpringConfig.java类

　　　　@Configuration：指明该类添加注解表明是配置类，取代ApplicationContext.xml

　　　　@ComponentScan(basePackage={"com.atguigu"})：配置包扫描

　　　　　　　　包扫描注解配置：@ComponentScan(basePackages={"com.atguigu"}

　　　　　　　　String[] basePackages配置要扫描的包，如果是多个包，用","隔开

　　　　　　　　<context:component-scan base-package="com.atguigu"/>

　　　　@Import(JdbcConfig.class)：引入其他配置类

　　　　　　属性value 配置另一个类的class对象

　　　　@Bean,Spring框架就会方法的返回值放在IOC容器

　　　　　　value属性：对象的唯一标识，配置文件中的id,默认就是方法名去掉get,首字母小写

　　SpringConfig.java

@Configuration
@ComponentScan(basePackages = {"com.atguigu"})
@Import(JdbcConfig.class)
public class SpringConfig {


}

2.  将SpringConfig.java中数据库的配置信息提取到JdbcConfig.java类中

　　（1）@PropertySource：引入外部配置文件

　　　　　　属性：value 字符串的数组,一个元素

　　　　@Value：定义数据库连接的4个字段的值

　　JdbcConfig.java

@PropertySource("db.properties")
public class JdbcConfig {
    /*
        @Value
            定义数据库连接的4个字符

    * */
    @Value("${jdbc.driver}")
    private String dirver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;
    /*
        配置连接池,并注入IOC容器中
        <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource"></bean>
        注解：@Bean,Spring框架就会方法的返回值放在IOC容器
        @Bean注解：
            value属性：对象的唯一标识，配置文件中的id,默认就是方法名去掉get,首字母小写
    * */
    @Bean(value = "dataSource")
    public DataSource getDataSource() throws PropertyVetoException {
        //创建连接池对象，DataSource接口实现类的对象
        //不要使用多台，应为DataSource没有设置数据库连接信息的方法
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass(dirver);
        dataSource.setJdbcUrl(url);
        dataSource.setUser(username);
        dataSource.setPassword(password);
        return dataSource;
    }

    /*
        迁移QueryRunner对象
        利用返回值，讲对象放在IOC容器
        将连接池对象，作为方法的参数传递
    * */
    @Bean
    public QueryRunner getQueryRunner(@Qualifier("dataSource")DataSource dataSource){
        QueryRunner queryRunner = new QueryRunner(dataSource);
        return queryRunner;
    }
}

3. db.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf8&useSSL=false
jdbc.username=root
jdbc.password=root

4. 测试类

public class MainTest {
    //启动Spring框架:定义的配置类启动
    //AnnotationConfigApplicationContext 构造方法,传递配置类的class对象
    private ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
    @Test
    public void test(){
        AccountService accountService = context.getBean(AccountService.class);
        Account account = new Account();
        account.setName("赵云");
        account.setMoney(5768D);
        accountService.saveAccount(account);
    }
}

 第五章、Spring框架对Junit的支持

　　（1）导入org.springframework.spring-test.jar

　　（2）@RunWith：Spring集成对junit支持：直接注入对象

　　　　@RunWith注解：

　　　　　　Junit底层有一个类（Main方法启动的）

　　　　　   Spring提供了一个类，取代了Junit底层的类

　　　　　　@RunWith注解的属性：value 是class类，传递一个类的class对象

　　　通过配置文件启动，或通过配置类启动

　　　　@ContextConfiguration:junit环境下使用，表明配置文件启动，还是配置启动

　　　　　　注解属性：String[] locations() defauls{}:配置文件启动

　　　　　　注解属性：Class<?>[] classes() default{}:配置类启动

 

　　测试类·

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
//配置文件方法启动的配置
//@ContextConfiguration(locations = "classpath:application.xml")
public class MainTest {
    @Autowired
    private AccountService accountService;
    @Test
    public void test(){
        Account account = new Account();
        account.setName("赵云");
        account.setMoney(5768D);
        accountService.saveAccount(account);

    }
}