Spring IOC ultra-Detailed use (2) iniciantes devem ver o uso de anotações para se conectar ao banco de dados usando montagem automática Injeção de dependência genérica Teste de unidade Spring

Uso de IOC (2)

Uso ultra-detalhado do Spring (1), o conteúdo inclui várias maneiras de obter componentes, atribuir valores a diferentes tipos de atributos, uso de FactoryBean, etc., endereço de entrega: uso ultra-detalhado do Spring IOC (1)

Uso do Spring AOP, endereço de entrega: uso detalhado do Spring AOP

Um, referenciar arquivos de propriedades externas

Use o pool de conexão do banco de dados C3P0 (a conexão é mysql8)

1. Pacote guia
   

2. Crie um arquivo c3p0.properties no diretório src, onde o conteúdo é:

jdbc.username=root
jdbc.password=root
jdbc.jdbcUrl=jdbc:mysql://localhost:3306/book?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone = GMT
jdbc.driverClass=com.mysql.jdbc.Driver
//以上key是自定义的，并不是C3P0标准的key

Nota:
(1) nome de usuário é uma palavra-chave no Spring. Para evitar que a chave no arquivo de configuração tenha o mesmo nome, você pode prefixar a chave no arquivo de configuração
(2) Ao conectar ao mysql8,
i. Use mysql- conector-java-5.1 .49.jar e superior
ii. O endereço url deve ser sufixado

3. Escrito em xml

(1) Use o espaço de nome de contexto para carregar arquivos de configuração externa

(2) Escrito em xml

     <!-- location属性固定写法：classpath表示引用类路径下的资源-->
     <context:property-placeholder location="classpath:c3p0.properties"/>
    
     <!-- 创建一个数据库连接池 -->
     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    
       <!-- ${key}动态取出配置文件中某个key对应的值 -->
    
       <property name="user" value="${jdbc.username}"></property>
       <property name="password" value="${jdbc.password}"></property>
       <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
       <property name="driverClass" value="${jdbc.driverClass}"></property>
    
    </bean>

4. teste

   @Test
   public void test() throws SQLException {
    
    
       ApplicationContext ioc = new ClassPathXmlApplicationContext("ioc.xml");
       DataSource dataSource = (DataSource)ioc.getBean("dataSource");
       System.out.println(dataSource.getConnection());
       //com.mchange.v2.c3p0.impl.NewProxyConnection@64c87930
   }

Dois, crie o bean por meio de anotação

Existem quatro anotações no Spring
(1) @Controller: é recomendado adicionar esta anotação aos componentes da camada de controle (Servlet)
(2) @Service: é recomendado adicionar esta anotação aos componentes da camada de lógica de negócios
(3) @Repository: recomenda-se aos componentes da camada de banco de dados (camada Dao) adicionar esta anotação
(4) @Component: Recomenda-se adicionar esta anotação aos componentes que não pertençam ao anterior

Nota:
i. Adicione qualquer anotação à classe do componente a ser criado para adicionar rapidamente este componente ao gerenciamento do contêiner ioc
ii. Use qualquer uma das quatro anotações acima, mas tente usar o recomendado

Etapas para uso:

(1) Importe o pacote aop para suportar o modo de anotação:

(2) Adicione as anotações acima à classe do componente a ser criado

import org.springframework.stereotype.Service;

    @Service
    public class BookService {
    
    
       //内容
    }

(3) Deixe o Spring escanear automaticamente os componentes anotados e usar o namespace de contexto no arquivo xml

<!-- context:component-scan：自动扫描组件 -->
<!-- base-package：指定扫描的包，会将此包下的所有包的所有加了注解的类，自动的扫描进ioc容器中 -->
   
<context:component-scan base-package="com.qizegao"></context:component-scan>
   
<!-- com.qizegao.test 与 com.qizegao.util包都会被扫描，扫描之后符合条件的类图标会加小s -->

Nota:

O comportamento padrão dos componentes adicionados ao contêiner usando anotações é consistente com o comportamento padrão dos componentes adicionados ao contêiner usando arquivos de configuração:
i. O id padrão do componente é a primeira letra do nome da classe em minúsculas
ii. O componente padrão é singleton

(4) Teste

 public void test() {
    
    
    ApplicationContext ioc = new ClassPathXmlApplicationContext("ioc.xml");
    System.out.println(ioc.getBean("bookService") == ioc.getBean("bookService"));
    //true
  }

Observação:
i. O id do componente pode ser modificado
ii. O componente pode ser modificado para várias instâncias, da seguinte forma:

@Service("newName") // 修改id为newName
  @Scope(value="prototype") // 修改bean为多实例
  public class BookService {
    
    
       //内容
  }

teste:

   public void test() {
    
    
       ApplicationContext ioc = new ClassPathXmlApplicationContext("ioc.xml");
       System.out.println(ioc.getBean("newName") == ioc.getBean("newName"));
       //false
   }

Três, especifique os componentes que não estão incluídos e apenas incluídos no Spring scan

//不包含
   <context:component-scan base-package="com.qizegao">
       <!-- 使用context:exclude-filter指定扫描时不包含的组件：
             1. type=annotation：按照注解进行排除，使用了expression中指定的注解(全类名)就不会被包含进来
             2. type=assignable：按照指定的类进行排除，expression中指定要排除的全类名
        -->
       <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Service"/>
   </context:component-scan>

//只包含
    //Spring默认是把包中所有满足条件的组件全部扫描进来，故应当先禁用默认的扫描规则
   <!-- use-default-filters="false"：禁用默认的扫描规则 -->
   <context:component-scan base-package="com.qizegao" use-default-filters="false">
        <!-- 使用context:include-filter指定扫描时只包含的组件：用法与context:exclude-filter一致 -->
        <context:include-filter type="assignable" expression="com.qizegao.test.BookService"/>
   </context:component-scan>

Quarto, use a anotação @Autowired para realizar a montagem automática de acordo com o tipo

Montagem automática: atribui automaticamente um valor a um determinado atributo. Deve ser atribuído ao componente correspondente a este atributo no container, o que requer que este componente esteja no container, caso contrário, um erro será reportado

1. Crie duas classes no pacote com.qizegao.test

  @Repository
  public class BookDao {
    
    
     public void saveBook() {
    
    
         System.out.println("正在使用BookDao保存图书");
     }
  }

  @Service
  public class BookService {
    
    
   
      @Autowired
      //使用此注解自动的为其赋值，无需再new
      private BookDao bookDao;
   
      public void save() {
    
    
          System.out.println("调用BookDao保存图书");
          bookDao.saveBook();
      }
  }

2. Deixe o Spring escanear os componentes anotados em xml

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

3. teste

public void test() {
    
    
   ApplicationContext ioc = new ClassPathXmlApplicationContext("ioc.xml");
   //BookService默认是单例的，使用class获取
   BookService bookService = ioc.getBean(BookService.class);
   bookService.save();
   /**
    * 调用BookDao保存图书
    * 正在使用BookDao保存图书
    */
}

Cinco, princípio de montagem automática de anotação @Autowired

   @Autowired
   private BookDao bookDao;

Primeiro vá para o contêiner para encontrar o componente correspondente de acordo com o tipo (BookDao): getBean (BookDao.class):
(1) Encontre um, atribua
(2) Não encontre, lance uma exceção
(3) Encontre vários (subclasses deste classe será encontrada) Também encontrado):

Use o nome da variável (bookDao) como o id para continuar a encontrar o componente correspondente no contêiner:
i. A correspondência é bem-sucedida, a montagem
ii. A correspondência falha, um erro é relatado

Nota:
(1)
@Autowired
@Qualifier ("xxx") // Usando esta anotação pode usar xxx como id para corresponder, em vez de usar o nome da variável como id
private BookDao bookDao;

(2) Monte se corresponder e atribua um valor nulo se falhar: @Autowired (obrigatório = falso)

Seis, use métodos @Autowired

1. Este método será executado automaticamente quando o bean for criado
2. Cada parâmetro deste método será injetado automaticamente de acordo com o acima

(1) Métodos em BookService

    //BookService与BookDao均已注册到ioc容器中
    @Service
    public class BookService {
    
    
       @Autowired(required=false)
       //参数的位置也可以使用@Qualifier注解
       public void method(@Qualifier("bookDao")BookDao bookDao) {
    
    
           System.out.println(bookDao); 
       }
    }

(2) Teste

  @Test
   public void test() {
    
    
       ApplicationContext ioc = new ClassPathXmlApplicationContext("ioc.xml");
       //运行后输出：com.qizegao.test.BookDao@2bbaf4f0
   }

Sete, a diferença entre @Autowired e @Resource

Os dois são intercambiáveis

@Autowired: a função mais poderosa, é a anotação definida pelo Spring, mas só suporta o framework Spring
@Resource: é extensível e é um padrão definido por Java, e também pode ser usado se você mudar para outro contêiner (não Primavera)

Oito, injeção de dependência genérica

Ao registrar um componente, seu tipo genérico também é o padrão de referência, conforme mostrado a seguir:

Nota: Ao registrar componentes com relação de herança, você só precisa adicionar anotações à subclasse, e a classe pai será automaticamente injetada sem adicionar

Nove, teste de unidade de primavera

(1) Pacote guia:

(2) Use duas anotações na classe de teste:
① @ContextConfiguration (locations = "classpath: ioc.xml")
especifica a localização do arquivo de configuração Spring

② @RunWith (SpringJUnit4ClassRunner.class)
especifica qual driver usar para teste de unidade, o padrão é Junit

(3) Benefícios: Não há necessidade de usar o método getBean para obter componentes, adicione diretamente a anotação @Autowired nos componentes a serem obtidos, e o Spring irá montar automaticamente

(4) Caso de uso:

 @ContextConfiguration(locations="classpath:ioc.xml")
    @RunWith(SpringJUnit4ClassRunner.class)
    public class test {
    
    
   
       @Autowired
       BookDao bookDao;
   
       @Test
       public void test() {
    
    
           System.out.println(bookDao);
           //com.qizegao.test.BookDao@62e136d3
       }
    }