java | (二十九)Spring框架（1）

体系结构

IOC（Inversion Of Control）控制反转

String框架上下文对象

spring上下文是spring framework运行时在JVM中使用的内存区域
spring上下文必需在使用前首先创建
spring上下文最核心的作用是创建、管理应用程序中的Bean对象
BeanFactory接口是spring上下文的顶级接口
BeanFactory子接口：
ApplicationContext：非Web应用Spring上下文接口（键结集成BeanFactory）
WebApplicationContext：Web应用spring上下文接口（直接继承ApplicationContext）

这次我们用maven来配置String
一般项目，要配置String应该要导入20多个jar包，用maven可以下载到仓库，具体教程参考这篇博文

maven的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>org.example</groupId>
  <artifactId>springBasic</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>springBasic</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
    <springVersion>5.0.10.RELEASE</springVersion>
  </properties>



  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
    <!--    Spring表达式    -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>${springVersion}</version>
    </dependency>
    <dependency>
      <!--    Spring核心    -->
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${springVersion}</version>
    </dependency>
    <dependency>
      <!--    Spring实体    -->
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>${springVersion}</version>
    </dependency>
    <dependency>
      <!--    Spring容器    -->
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${springVersion}</version>
    </dependency>

    <dependency>
      <!--    Spring-web   -->
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${springVersion}</version>
    </dependency>

  </dependencies>

  <build>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <!-- clean lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#clean_Lifecycle -->
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- default lifecycle, jar packaging: see https://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-jar-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
        <!-- site lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#site_Lifecycle -->
        <plugin>
          <artifactId>maven-site-plugin</artifactId>
          <version>3.7.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-project-info-reports-plugin</artifactId>
          <version>3.0.0</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

web.xml配置上下文加载路径和Spring监听接口

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <!--    配置上下文加载的xml文件路径-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            classpath:com/model/conf/spring/ApplicationContext.xml
        </param-value>
    </context-param>
    
    <!--配置上下文加载时的监听接口-->
    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>
</web-app>

其中，ApplicationContext是自己创建的，根据那篇博文，maven下载好后可以直接创建。
如果spring的监听找不到，原因可能是包没有导到位，这里应该是spring-web包，可以在下图位置将相关包加到lib路径下

多个spring配置文件

在原有的基础上，又多建了一个

web.xml配置

    <!--    配置上下文加载的xml文件路径-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            classpath:com/model/conf/spring/ApplicationContext.xml,
            classpath:com/model/conf/spring/spring-client.xml
        </param-value>
    </context-param>

第二种方法：
在ApplicationContext.xml用import导入

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--使用import元素导入其它spring上下文bean定义文件-->    
    <import resource="spring-client.xml"/>
</beans>

配置管理bean对象

bean常用属性：
id:bean对象在spring上下文中的唯一标识
name:bean对象别名，可有多个
class:bean对象的类型名称
scope：bean对象的存储范围
autowire:bean对象注入方式
init-method：bean对象在创建时调用的初始化方法名称
depends-on：bean对象所依赖的对象名称
lazy-init：设置典型是否延迟初始化
constructor-arg:创建bean对象使用的有参构造器参数设置，常用属性：index，ref，type,value
property:
设置bean对象成员属性
常用属性：nane，ref，value

在xml文件中
首先创建一个Bean类Person及其依赖注入类Printer
Person.java

package com.model.user;

public class Person {
    
    
    private String name;
    private int age;
    private String sex;
    private Printer printer;

    public Printer getPrinter() {
    
    
        return printer;
    }

    public void setPrinter(Printer printer) {
    
    
        this.printer = printer;
    }

    public Person(String name, int age, String sex) {
    
    
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public Person() {
    
    
    }

    public void init(){
    
    
        System.out.println("调用init初始化方法");
        this.name = "liang";
        this.age = 22;
        this.sex = "男";
    }
}

Printer.java（用于测试，先不写内容）

package com.model.user;
public class Printer {
    
    
}

ApplicationContext.xml

<bean id="person" class="com.model.user.Person" init-method="init"
    name="person2,person3,person4" lazy-init="false" depends-on="printer">
        <property name="printer" ref="printer"></property>
    </bean>

    <bean id="printer" class="com.model.user.Printer" lazy-init="true"></bean>

init是初始化方法，表示创建时就调用；depend-on属性为依赖注入类的名称；在Person类下，其依赖注入类Printer要有set方法。
构造子方式注入bean对象
完善上面的printer类，并加上Ink类

package com.model.user;
public class Printer {
    
    
    private Ink ink;//依赖的Ink类型javabean对象

    public Printer(Ink ink) {
    
    
        System.out.println("构造器方式注入依赖的bean对象");
        this.ink = ink;
    }

    public Printer() {
    
    
    }

    public void printFile(){
    
    
        System.out.println("正在打印" + ink.getColor());
    }
}

package com.model.user;

public class Ink {
    
    
    private String color;

    public Ink(String color) {
    
    
        this.color = color;
    }

    public Ink() {
    
    
    }

    public String getColor() {
    
    
        return color;
    }

    public void setColor(String color) {
    
    
        this.color = color;
    }
}

在xml中

<bean id="printer" class="com.model.user.Printer" lazy-init="true">
        <!--构造子方式注入的依赖Ink-->
        <constructor-arg index="0" ref="ink"></constructor-arg>
    </bean>

    <bean id="ink" class="com.model.user.Ink" >
        <property name="color" value="blue"></property>
    </bean>

注解

使用注释标识java类
@Conponent javabean通用注释，涵盖所有类型bean，应用在类上
@Repository 数据处理层组件注释，应用在类上，通常标识Dao组件
@Service 服务层组件注释，应用在类上，通常标识控制器组件
@Controller 控制层组件注释，应用在类上，通常标识控制器组件
@Lazy 是头延迟初始化注释，应用在类上
@DependsOn 设置依赖的组件集合注释，应用在类上
以上都应用在类上
@Resource 设置依赖bean注释，应用在属性或set方法上
@Autowired 设置按类型自动注入依赖bean注释，应用在属性或set方法上
@Scope 设置bean的作用域范围，应用在类上
@Value 设置属性默认初始值，应用在属性或set方法

例子：
使用@Repository，UserDao.java，其相关的IUserDao不列出来了

package com.model.dao;

import org.springframework.stereotype.Repository;

@Repository(value = "UserDaoBean")
public class UserDao implements IUserDao {
    
    

    @Override
    public void addUser() {
    
    
        System.out.println("向数据库存入User");
    }
}

service层

package com.model.server;

import com.model.dao.IUserDao;
import com.model.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service("UserServiceImpBean")
public class UserServer implements IUserServer{
    
    

    @Autowired
    private IUserDao userDao;
    @Override
    public void addUser() {
    
    
        new UserDao().addUser();
    }
}

@Autowired 保证当前spring上下文中只有一个此类型的bean对象

servlet：

package com.model.controller;

import com.model.server.IUserServer;
import com.model.server.UserServer;
import org.springframework.stereotype.Service;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class UserController extends HttpServlet {
    
    
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    
    
        WebApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(this.getServletContext());
        IUserServer userServer = (UserServer)context.getBean("UserServiceImpBean");
        userServer.addUser();

    }
}

结果：

@Resource注入方式
在原有代码加入SystemDaoImp

package com.model.dao;

import org.springframework.stereotype.Repository;

@Repository(value = "SystemDaoImp")
public class SystemDaoImp implements ISystemDao {
    
    
    @Override
    public void systemAction() {
    
    
        System.out.println("系统操作~~~");
    }
}

在UserServer.java中添加该类

    @Resource(name = "SystemDaoImp")
    private ISystemDao systemDaoImp;

并且加以判断是否注入

        System.out.println("判断systemDaoImp是否注入" + (systemDaoImp == null));

结果为false，不为空，表示注入成功
@Resource有name和type属性，如果未设置 name属性值，也未设置type属性值，则首先按照默认字段名称查找，道道直接注入，找不到则按照type方式类型查找，如果找到则注入；找不到或找到一个以上则输出异常。

log4j

是Apache一个开源项目，提供系统日志的管理服务，以AOP模式切入到应用当中。
组成：

属性设置：
.Xml文件配置
.properties文件配置
Logger日志级别
用来表示输出什么样的日志信息
8个级别从低到高：ALL,TRACE,DEBUG,INFO,OFF,FATAL,ERROR,WARN

Appender输出源
Appender接口定义日志信息输出的目的地
ConsoleAppender 输出到控制台
FileAppender 输出保存为目标日志文件
DailyRollingFileAppender 每日商城一个日志文件
RollingFIleAppender 文件到达指定尺寸产生新文件
WriterAppender 日志信息以流格式发送到指定的地方

Layout日志信息输出格式
Layout抽象类定义以什么样的格式输入日志信息
PatternLayout 自定义格式
SimpleLayout 包含信息级别、信息字符串
HTMLLayout html表格式布局
TTCCLayout 时间、线程、类别等信息

PatternLayout的属性ConversionPattern用来设置日期时间输出格式

基本配置

# 设置log4j 根日志级别和输出目的地
log4j.rootLogger= INFO,R, CONSOLE

#  输出日志到 CONSOLE
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{
    
    yyyy-MM-dd HH:mm:ss,SSS} [%t] %-5p %C{
    
    1} : %m%n

#  输出日志到 FILE
log4j.appender.R=org.apache.log4j.RollingFileAppender
log4j.appender.R.File=D://L.log
log4j.appender.R.MaxFileSize=3000KB
log4j.appender.R.MaxBackupIndex=10
log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=-X %-d{
    
    yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m -(:%L)%n

# 设置springframework 日志级别为INFO
log4j.logger.org.springframework=INFO
## JDBC SQL
log4j.logger.java.sql.Connection=ERROR
log4j.logger.java.sql.Statement=ERROR
log4j.logger.java.sql.PreparedStatement=ERROR