Spring_day02

第一章、注解与包扫描

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);

    }
}

 

上一篇:C++学习笔记 3


下一篇:SQL优化实战:利用临时表让update执行得飞快