5分时时彩注册网址_Java匹马行天下之J2EE框架开发——Spring—>用IDEA开发Spring程序（01）

时间:2019-11-22 22:20:57
浏览:0

一、创建项目

*注：在IDEA中我创建的Maven项目，不了解Maven的许多人可不也能看我完后的博客“许多人同时走进Maven——知己知彼”，了解Maven后可不也能看我完后的博客“Maven的安装与配置”，自行安装，行动起来吧。

二、加载依赖

在pom.xml文件中加在Spring依赖和日志相关依赖

<dependencies>
  <!--测试相关-->
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</scope>
  </dependency>
  <!--Spring核心基础依赖-->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>5.0.2.RELEASE</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.0.2.RELEASE</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>5.0.2.RELEASE</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-expression</artifactId>
    <version>5.0.2.RELEASE</version>
  </dependency>
  <!--日志相关-->
  <dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.2</version>
  </dependency>
  <dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
  </dependency>
</dependencies>

三、项目型态

在main目录下面创建java和resources目录

四、基础代码实现（练手）

创建TestDao接口和实现类
获得TestDao实现类的实例
- 在完后开发中，许多人是直接new另一一一还还有一个对象即可。即：`private TestDao dao = new TestDaoImpl();`
- 在学习Spring完后，将由Spring来创建对象的实例 --> 即：`IoC 控制反转（Inverse of Control）`
  
  完后可不也能也能实例对象时，从Spring工厂（容器）中获得即可，可不也能也能将实现类的全限定名称配置到xml文件中。

创建dao包，在dao包下创建TestDao接口和TestDao接口的实现类，型态如下图：

TestDao接口代码示例：

package dao;

public interface TestDao {
    public void sayHello();
}

TestDaoImpl实现类代码示例：

package dao;

public class TestDaoImpl implements TestDao{
    @Override
    public void sayHello() {
        System.out.println("Hello,Spring!");
    }
}

在resources资源目录点击右键，依次选折 New-->XML Configuration File-->Spring Config，创建applicationContext.xml的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/10001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--把testDao对象的创建权交给Spring-->

    <!-- <bean> 配置可不也能也能


创建的对象

        id ：用于完后

从Spring容器中获得实例时使用的

        class ：可不也能也能


创建实例的全限定类名-->

<bean id="testDao" class="dao.TestDaoImpl"></bean> </beans>

创建test包，在test包下创建测试类SpringTest　　

package test;

import dao.TestDao;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {

@Test

public void demo1(){

    // 完后

开发，此人

手写new出对象

    TestDao dao= new TestDaoImpl();

    dao.sayHello();

}@Test


public void demo2() {

    // 现在从spring容器中获得对象实例

    // 1 、获得容器

    //初始化Spring容器ApplicationContext，加载配置文件

    ApplicationContext application = new ClassPathXmlApplicationContext("applicationContext.xml");

    // 2、获得内容 ，注意此时可不也能

可不也能


此人

new出对象了，都是从spring容器中获得

    //通过容器获取testDao实例

    TestDao testDao = (TestDao) application.getBean("testDao");

    testDao.sayHello();

}

IoC（Inverse of Control）反转控制的概念，什么都有我将另另一一一还还有一个在线程池中手动创建TestDaoImpl对象的控制权，交由Spring框架管理。
简单说，什么都有我创建TestDaoImpl对象的控制权被反转到了Spring框架。

点击测试土办法左侧的运行按钮，选折 Run，测试代码

运行后控制台显示结果

项目运行成功！！！！！！！

五、Spring入门案例：DI(掌握)

DI ：Dependency Injection ：依赖注入
is a ：是另一一一还还有一个，继承。
has a：有另一一一还还有一个，成员变量，依赖。

 class B {
       private A a;   // B类依赖A类，B类使用A类。
    }

    依赖：另一一一还还有一个对象可不也能也能


使用另另一一一还还有一个对象。
    注入：通过setter土办法

进行另另一一一还还有一个对象实例设置。

　　类似：

class BookServiceImpl {
        // 完后

开发：接口 = 实现类（service和dao耦合了，写死了，知道具体的实现类是谁，那么我的具体实现类变化，那么这行代码也得跟着变）
        // private BookDao bookDao = new BookDaoImpl();

         // spring完后

（解耦：service实现类使用了dao的接口，另另一一一还还有一个就真不知道具体的实现类是谁了）
        private BookDao bookDao;
        setter土办法

   }

模拟spring执行过程
    创建service实例：BookService bookService = new BookServiceImpl();   => IoC <bean>
    创建dao实例：BookDao bookDao = new BookDaoImple();                  => IoC
    将dao设置给service：bookService.setBookDao(bookDao);                => DI <property>

具体代码实现：

实现步骤：

创建BookDao接口和实现类
创建BookService接口和实现类
将dao和service配置到 applicationContext.xml文件中
使用api测试

项目型态：

加载依赖：

在pom.xml文件中加在Spring依赖和日志相关依赖

<dependencies>
  <!--测试相关-->
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</scope>
  </dependency>
  <!--Spring核心基础依赖-->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>5.0.2.RELEASE</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.0.2.RELEASE</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>5.0.2.RELEASE</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-expression</artifactId>
    <version>5.0.2.RELEASE</version>
  </dependency>
  <!--日志相关-->
  <dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.2</version>
  </dependency>
  <dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
  </dependency>
</dependencies>

BookDao接口和实现类

package dao;

public interface BookDao {
    void save();
}

package dao;

public class BookDaoImpl implements BookDao {
    @Override
    public void save() {
        System.out.println("实现加在功能");
    }
}

BookService接口和实现类

package Service;

public interface BookService {
    void addBook();
}

package Service;

import dao.BookDao;
import dao.BookDaoImpl;

public class BookServiceImpl implements BookService {

    //土办法

一：完后

，接口=实现类
    //private BookDao bookDao= new BookDaoImpl();

    //土办法

二：现在，接口+setter土办法

    private BookDao bookDao;
    public void setBookDao(BookDao bookDao){
        this.bookDao=bookDao;
    }

    @Override
    public void addBook() {
    this.bookDao.save();

    }
}

将dao和service配置到 applicationContext.xml文件中

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/10001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- <bean> 配置可不也能也能


创建的对象
            id ：用于完后

从Spring容器中获得实例时使用的
            class ：可不也能也能


创建实例的全限定类名-->
    <!--
   模拟spring执行过程
       创建service实例：BookService bookService = new BookServiceImpl();   => IoC <bean>
       创建dao实例：BookDao bookDao = new BookDaoImple();                  => IoC
       将dao实例设置给service实例：bookService.setBookDao(bookDao);         => DI <property>

       <property> 用于进行属性注入
           name ： Bean的属性名称，通过setter土办法

获得
               setBookDao  =>  BookDao =>  bookDao
           ref ：另另一一一还还有一个Bean的id值的引用
   -->
    <!-- 创建service实例 -->
    <bean id="bookServiceId" class="Service.BookServiceImpl">
        <!-- 将dao实例设置给service实例 -->
        <property name="bookDao" ref="bookDaoId"></property> <!-- 用于进行属性注入 -->
    </bean>
    <!-- 创建dao实例 -->
    <bean id="bookDaoId" class="dao.BookDaoImpl"></bean>
</beans>

使用api测试

创建test包，在test包下创建测试类SpringTest

package test;

import Service.BookService;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {
    @Test
    public void Test1(){
        // 完后

开发，此人

手写new出对象
        // BookService bookService = new BookServiceImpl();
        // bookService.addBook();
    }

    @Test
    public void Test2(){
        // 现在从spring容器中获得对象实例
        // 1 、获得容器
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 2、获得内容 ，注意此时可不也能

可不也能


此人

new出对象了，都是从spring容器中获得
        BookService bookService = (BookService) applicationContext.getBean("bookServiceId");

        bookService.addBook();
    }
}

DI：Dependency Injection 依赖注入，在Spring框架负责创建Bean对象时，动态的将依赖对象注入到Bean组件。
getBean("bookServiceId"); 从spring容器中获得指定名称对象的实例时，会先判断本实例对象有无可不也能也能使用许多实例化对象，可能性设置了< property name="bookDao" ref="bookDaoId">< /property>，说明可不也能也能使用许多实例化对象，什么都有就根据许多Bean的id值的引用，去spring容器中获得指定名称对象的实例，大约将dao实例设置给service实例。

运行后控制台显示结果

这就成功了，开心一下，通过这另一一一还还有一个案例，多Spring有了初步的理解，加油！

六、Spring的核心API（了解）

api整体了解即可，完后不使用，在学习过程可不也能也能。

BeanFactory ：这是另一一一还还有一个工厂，用于生成任意Bean。

采取延迟加载，第一次调用getBean(); 时才会初始化Bean。（即实例化对象）
ApplicationContext ：是BeanFactory的子接口，功能更强大。（国际化防止、事件传递、Bean自动装配、各种不同应用层的Context实现）。 采取非延时加载，当配置文件被加载时，就进行对象的实例化。
- ClassPathXmlApplicationContext 用于加载classpath（类路径/src）下的xml
  - 加载xml运行时位置 --> /WEB-INF/classes/xxx.xml
- FileSystemXmlApplicationContext 用于加载指定盘符下的xml
  - 加载xml运行时位置 --> /WEB-INF/xxx.xml
  - 通过java web学习过的 ServletContext.getRealPath(); 获得具体盘符

示例代码如下：

package test;

import Service.BookService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;

public class SpringTest {
    @Test
    public void Test1(){
        // 完后

开发，此人

手写new出对象
        // BookService bookService = new BookServiceImpl();
        // bookService.addBook();
    }

    @Test
    public void Test2(){
        // 现在从spring容器中获得对象实例
        // 1 、获得容器
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 采取非延时加载，当配置文件被加载时，就进行对象的实例化。
        // 2、获得内容 ，注意此时可不也能

可不也能


此人

new出对象了，都是从spring容器中获得
        BookService bookService = (BookService) applicationContext.getBean("bookServiceId");

        bookService.addBook();
    }

    @Test
    public void demo3() {
        // 现在从spring容器中获得对象实例，使用的是BeanFactory，上面可不也能也能


另一一一还还有一个Resource，该Resource又是另一一一还还有一个接口，可不也能也能


找它的实现类ClassPathResource
        // 1 、获得容器
        BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
        // 2、获得内容 ，注意此时可不也能

可不也能


此人

new出对象了，都是从spring容器中获得
        BookService  bookService = (BookService) beanFactory.getBean("bookServiceId"); // 采取延迟加载，第一次调用getBean(); 时才会初始化Bean（即实例化对象）。

        bookService.addBook();
    }
}

七、装配Bean:基于XML

3种bean实例化土办法：

使用`默认构造土办法 `实例化
使用`静态工厂土办法 `实例化
使用`实例工厂土办法 `实例化

使用默认构造土办法实例化

格式：

<bean id="从Spring容器中获得实例时使用的" class="可不也能也能


创建实例的全限定类名"></bean>
类似:<bean id="userServiceId" class="Service.UserServiceImpl"></bean>

示例中用到的 UserService.java 和 UserServiceImpl.java 代码同上面实例中的代码，这里不再赘述！

在spring容器中进行配置：

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/10001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

 

</beans>

　　测试代码：

public class TestIoC {
    @Test
    public void demo01() {
        // 完后

开发，此人

手写new出对象
        UserService userService = new UserServiceImpl(); // 直接手动创建实例

        userService.addUser();
    }

    @Test
    public void demo02() {
        // 现在从spring容器中获得对象实例
        // 1 、获得容器
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 2、获得内容 ，注意此时可不也能

可不也能


此人

new出对象了，都是从spring容器中获得
        UserService userService = (UserService) applicationContext.getBean("userServiceId");

        userService.addUser();
    }
}

使用`静态工厂土办法 `实例化

静态工厂：常用与spring整合许多框架(工具)时。
静态工厂：用于生成实例对象，所有的土办法可不也能也能是static。

示例中用到的 UserService.java 和 UserServiceImpl.java 代码同上面实例中的代码，这里不再赘述！

格式：

<bean id=""  class="工厂全限定类名"  factory-method="静态土办法

名称">

在spring容器中进行配置：

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/10001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

 
</beans>

 静态工厂类代码：

public class MyBeanFactory {

    /**
     * 创建实例的静态工厂，所有的土办法

可不也能也能


是静态的(static)。
     * 
     * @return
     */
    public static UserService createService() {
        return new UserServiceImpl();
    }

    // 还有创建许多实例的静态工厂
    // ......
}

　　测试代码：

TestStaticFactory.java

/**
 * 第二种实例化Bean 的土办法

 ：使用静态工厂土办法

实例化
 *
 */
public class TestStaticFactory {

    @Test
    public void demo01() {
        // 完后

：使用自定义的静态实例工厂
        UserService userService = MyBeanFactory.createService();

        userService.addUser();
    }

    @Test
    public void demo02() {
        // 现在：使用spring 工厂：将自定义的静态工厂创建的实例交给spring管理

 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

UserService userService = applicationContext.getBean("userServiceId", UserService.class); // 这人

土办法

底层会自动转换 

// UserService userService = (UserService) applicationContext.getBean("userServiceId");

 userService.addUser();

 }

 }

注意：当使用JDK版本为1.8时，运行上面的测试代码会突然出現另一一一还还有一个问題图片： java.lang.IllegalArgumentException，

问題图片防止链接：使用Junit测试另一一一还还有一个 spring静态工厂实例化bean 的例子，所有代码都那么问題图片，但会突然出現java.lang.IllegalArgumentException异常小结：在完后的开发中，工厂类可不也能可不也能许多人去手写，可能性别人可能性写好了，许多人通过编写配置文件，把别人写好的工厂类拿来，写上要用的土办法名，但会把它生产后的实例给Spring存起来，完后许多人要用那此实例，跟Spring说一下，去拿就可不也能了。

使用`实例工厂土办法 `实例化

实例工厂：可不也能也能先有工厂的实例对象，但会通过实例对象去创建对象。特点：提供所有的土办法都是“非静态”的。

示例中用到的 UserService.java 和 UserServiceImpl.java 代码同上面实例中的代码，这里不再赘述！

在spring容器中进行配置：

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/10001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 
</beans>

　　静态工厂类代码：

public class MyBeanFactory {

    /**
     * 创建实例的工厂，所有土办法

非静态
     * 
     * @return
     */
    public UserService createService() {
        return new UserServiceImpl();
    }

    // 还有创建许多实例的工厂
    // ......
}

　　测试代码：

TestFactory.java

package test;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * 第并都是实例化Bean 的土办法

 ：使用实例工厂土办法

实例化
 *  */
public class TestFactory {

    @Test
    public void demo01() {
        // 完后

：使用自定义的实例工厂
        // 1、创建工厂实例
        MyBeanFactory myBeanFactory = new MyBeanFactory();
        // 2、通过工厂实例，获得对象
        UserService userService = myBeanFactory.createService();

        userService.addUser();
    }

    @Test
    public void demo02() {
        // 现在：使用spring 工厂：将自定义的实例工厂创建的实例交给spring管理

 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

UserService userService = applicationContext.getBean("userServiceId", UserService.class); // 这人

土办法

底层会自动转换

 // UserService userService = (UserService) applicationContext.getBean("userServiceId");

 userService.addUser();

 }

 }

一、Bean的种类
- 普通bean ：完后操作的都是普通bean。类似：< bean id="xxx" class="A" >，这句代码的意思是：Spring直接创建A的实例，并返回。
- FactoryBean ：是另一一一还还有一个特殊的bean，具有工厂生成对象能力，但会可不也能也能生成特定的对象。
  
  你会生产对象的bean 可不也能也能实现FactoryBean 接口，此接口提供土办法 getObject(); 用于获得特定bean。
  - 示例：< bean id="xxx" class="FB">，这句代码的意思是：Spring会先创建FB实例，但会调用getObject(); 土办法，并返回土办法的返回值。
    即大约如下两行代码：FB fb = new FB();return fb.getObject();
- BeanFactory 和 FactoryBean 对比？
  - BeanFactory ：是另一一一还还有一个生产bean的工厂，用于生成任意的bean。
  - FactoryBean ：是另一一一还还有一个特殊的bean，用于生成另另一一一还还有一个特定的bean。
    - 类似：ProxyFactoryBean ，此工厂bean用于生产代理对象的实例。< bean id="xxx" class="….ProxyFactoryBean">，这句代码的意思是：获得代理对象的实例。即AOP使用。
- spring容器中bean元素id和name属性的区别？
  - 在spring容器中加在以下配置：
    
    示例：< bean id="userServiceId" class="com.itheima.a_ioc.UserServiceImpl">
  - bean节点中id和name的区别：
  - 区别一：
    - id ：指定唯一实例引用
    - name ：可不也能指定多个实例引用，类似name="名称1, 名称2"
  - 区别二：
    - id ：id的命名要满足XML对ID属性命名规范
      
      类似：可不也能也能以字母结束了，可不也能使用字母、数字、连字符、下划线、句话、冒号
    - name ：可能性Bean的名称中中有特殊字符，就可不也能也能使用name属性
      
      类似： < bean name="# boy" class="cn.itheima.ioc.Boy"/>
    - 可能性name属性可不也能相同，所完后突然出現Bean会覆盖完后突然出現的同名的Bean。
  总结：项目开发的完后，强烈要求用id，可能性id可不也能表示唯一引用。

二、Bean的作用域

Bean 的作用域：用于选折 spring所创建bean 的实例个数。

取值：
- singleton 单例，默认值。
- prototype 多例，每执行一次getBean() 将获得另一一一还还有一个实例。类似：在struts整合spring时，可不也能也能配置action为多例。
配置示例：默认状况下会在容器启动时初始化bean，但许多人可不也能指定Bean节点的 lazy-init="true" 来延迟初始化bean，这完后，可不也能也能第一次获取bean会才初始化bean。
- 类似：`< bean id="xxx" class="xxx" scope="xxx">`
类似：< bean id="xxx" class="service.UserServiceImpl" lazy-init="true">
可能性想对所有bean都应用延迟初始化，可不也能在根节点beans设置 default-lazy-init="true"，

类似：< beans default-lazy-init="true“>
Portlet是基于java的web组件，由portlet容器管理，并由容器防止请求，生产动态内容。

Portals使用portlets作为可插拔用户接口组件，提供信息系统的表示层。
作为利用servlets进行web应用编程的下一步，portlets实现了web应用的模块化和用户中心化。

在spring容器中进行配置：

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/10001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="userServiceId" class="com.itheima.d_scope.UserServiceImpl" scope="prototype"></bean>
</beans>

　　测试代码：

TestScope.java

public class TestScope {

    @Test
    public void demo01() {
        // 现在：使用spring 工厂

 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

UserService userService1 = applicationContext.getBean("userServiceId", UserService.class);

 // 这人

土办法

底层会自动转换 

UserService userService2 = applicationContext.getBean("userServiceId", UserService.class); 

// 这人

土办法

底层会自动转换

 // 默认Bean的作用域是单例，什么都有打印的对象的地址是一样的

 // System.out.println(userService1); // service.UserServiceImpl@2ac273d3

 // System.out.println(userService2); // service.UserServiceImpl@2ac273d3

 // 现在在配置文件中加在scope属性，值为prototype，此时Bean的作用域变为多例了，再次打印，输出地址不一样了 

System.out.println(userService1);

 //service.UserServiceImpl@6641000dd7 

System.out.println(userService2); 

//service.UserServiceImpl@52a86356

 }

 }

三、Bean的生命周期

Bean 的生命周期详情

instantiate bean 对象实例化。
populate properties 封装属性。
可能性Bean实现 BeanNameAware，则表示执行 setBeanName。
可能性Bean实现 BeanFactoryAware 可能性 ApplicationContextAware，则表示设置实例工厂（setBeanFactory）可能性上下文对象（setApplicationContext）。
可能性趋于稳定类实现 BeanPostProcessor（后防止Bean），则表示执行 postProcessBeforeInitialization。
可能性Bean实现 InitializingBean，则表示执行 afterPropertiesSet。
调用，则表示指定初始化土办法 init。
可能性趋于稳定类实现 BeanPostProcessor（防止Bean），则表示执行 postProcessAfterInitialization。
执行业务防止
可能性Bean实现 DisposableBean，则表示执行 destroy。
调用，则表示指定销毁土办法 customerDestroy。

四、Bean 的初始化和销毁

目标土办法执行前和执行后，将进行Bean的初始化或销毁。

　　示例：<bean id="xxx" class="xxx" init-method="初始化的土办法名称" destroy-method="销毁的土办法名称"></bean>示例代码如下：

编写目标类代码：

UserService.java

public interface UserService {
    void addUser();
}

UserServiceImpl.java

public class UserServiceImpl implements UserService {

    @Override
    public void addUser() {
        System.out.println("e_lifecycle add user");
    }

    public void myInit() {
        System.out.println("我的初始化土办法

");
    }

    public void myDestory() {
        System.out.println("我的销毁土办法

");
    }
}

在spring容器中进行配置：

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/10001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

　　编写测试代码：

public class TestLifecycle {

    @Test
    public void demo01() throws Exception {
        // 现在：使用spring 工厂（spring 容器）

 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

 UserService userService = (UserService) applicationContext.getBean("userServiceId"); 

 userService.addUser(); // 要想使我的销毁土办法

也执行，必可不也能也能


求：

 // 1.容器可不也能也能


先close，我的销毁土办法

才会执行; 

 // 2.可不也能也能


是单例的（spring所创建该bean的实例个数可不也能也能


另一一一还还有一个）即bean中的scope配置成默认即可。

 // 可能性此close土办法

在接口 ApplicationContext 中那么定义，而在实现类中提供了该土办法

，许多人可不也能使用反射，可能性反射最后执行的什么都有我实现类中的土办法

。 

 applicationContext.getClass().getMethod("close").invoke(applicationContext); } }

五、BeanPostProcessor 后防止Bean
是由spring提供的并都是机制，假如有一天实现类实现此接口BeanPostProcessor，并将该实现类提供给spring容器，spring容器将自动执行另一一一还还有一个土办法：在初始化土办法前执行before()土办法，在初始化土办法后执行after()土办法。配置格式：这句代码的意思什么都有我：把实现类提供给了spring容器。
Factory hook(勾子) that allows for custom modification of new bean instances, e.g. checking for marker interfaces or wrapping them with proxies.
spring提供工厂勾子，用于修改实例对象，可不也能生成代理对象。(是AOP底层)

谷歌翻译：Factory hook（勾子），允许自定义修改新的bean实例，类似：检查标记接口或用代理包装它们。

许多人来模拟这句话的意思：

before()    => postProcessAfterInitialization(Object bean, String beanName) 
after()     => postProcessBeforeInitialization(Object bean, String beanName) 

A a = new A();

a = B.before(a); // 将a的实例对象传递给后防止bean，可不也能那此都没做，也可不也能做许多事情，比如：生成jdk代理对象并返回给a，另另一一一还还有一个a就从实例对象变成代理对象了，此时的a就具有了AOP功能；再比如，可能性把null返回给a，再用a去调用土办法

，就会突然出現空指针异常。
a.init();
a = B.after(a);

// 以下是AOP演示：
// 许多人现在在后防止Bean 代码执行完完后

，把jdk代理对象返回给a。让a在调用addUser()完后

先做许多事情

// 完后

要做的事情
a.addUser(); // 在目标土办法

的前后可不也能做许多事情，类似：开启事务、提交事务、性能监控(前后时间)等等
// 完后

要做的事情

a.destroy();

　　目标类示例代码如下：

UserService.java

public interface UserService {
    void addUser();
}

　　UserServiceImpl.java

public class UserServiceImpl implements UserService {

    @Override
    public void addUser() {
        System.out.println("e_lifecycle add user");
    }

    public void myInit() {
        System.out.println("我的初始化土办法

");
    }

    public void myDestory() {
        System.out.println("我的销毁土办法

");
    }
}

　　实现类示例代码如下：

MyBeanPostProcessor.java

public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("执行了前土办法

：" + beanName);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(final Object bean, String beanName) throws BeansException {
        System.out.println("执行了后土办法

：" + beanName);
        // 传入的参数bean是许多人的目标对象，此时许多人的目标对象可不也能也能


另一一一还还有一个接口，那么许多人的代理对象也可不也能也能


另一一一还还有一个接口
        // 生成jdk代理对象
        return Proxy.newProxyInstance(
                MyBeanPostProcessor.class.getClassLoader(), // 代理对象
                bean.getClass().getInterfaces(), // 目标对象
                new InvocationHandler() {

                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("---开启事务---");
                        Object obj = method.invoke(bean, args); // 执行目标土办法

，本例中的目标土办法

是addUser
                        System.out.println("---关闭事务---");
                        return obj;
                    }
                }); // 代理的防止线程池
    }
}

在spring容器中进行配置：

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/10001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

　　测试示例代码如下：

TestLifecycle.java

public class TestLifecycle {

    @Test
    public void demo01() throws Exception {
        // 现在：使用spring 工厂（spring 容器）
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml"); 

        UserService userService = (UserService) applicationContext.getBean("userServiceId"); 

        userService.addUser();

       // 要想使我的销毁土办法

也执行，必可不也能也能


求：

      // 1.容器可不也能也能


先close，我的销毁土办法

才会执行;

      // 2.可不也能也能


是单例的（spring所创建该bean的实例个数可不也能也能


另一一一还还有一个）即bean中的scope配置成默认即可。

      // 可能性此close土办法

在接口 ApplicationContext 中那么定义，而在实现类中提供了该土办法

，许多人可不也能使用反射，可能性反射最后执行的什么都有我实现类中的土办法

。 

      applicationContext.getClass().getMethod("close").invoke(applicationContext);

      }

      }

运行结果截图：
问題图片1：后防止bean作用某另一一一还还有一个目标类，还是所有目标类？

答：所有。
问題图片2：如可只作用另一一一还还有一个？

答：通过获取"参数2"beanName进行控制。类似："xxx".equals(method.getName());

六、依赖注入Bean 的属性(xml)

注入依赖对象可不也能采用：手工装配或自动装配。在实际应用中建议使用手工装配，可能性自动装配会产生未知状况，开发人员无法预见最终的装配结果。
- 手动装配：一般进行配置信息都采用手动装配。
  - 基于xml装配基于注解装配 => 完后讲解
    - 构造土办法注入
    - 属性setter土办法注入
    - 接口注入（spring不支持）
- 自动装配：在struts 和spring 整合的完后使用自动装配。
  - byType：按类型装配
  - byName：按名称装配
  - constructor：按构造装配
  - autodetect：不选折装配（即自动装配）

构造土办法

Bean对象类：

public class User {

    private Integer uid;
    private String username;
    private Integer age;

    public User(Integer uid, String username) { // 构造土办法

一
        super();
        this.uid = uid;
        this.username = username;
    }

    public User(String username, Integer age) { // 构造土办法

二
        super();
        this.username = username;
        this.age = age;
    }
    // 省略getter 和 setter 土办法

    // ......

在spring容器中进行配置：

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/10001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 
</beans>

setter土办法

在spring容器中进行配置：

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/10001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

飞艇ipad_“邂逅你，邂逅爱情”平凉第二届相亲文化节进入倒计时

1.5分快3平台客服_釜山之旅走进韩国最地道的酱蟹门店普乐(PRO)

5分时时彩注册网址_Java匹马行天下之J2EE框架开发——Spring—>用IDEA开发Spring程序（01）

一、创建项目

二、加载依赖

三、项目型态

四、基础代码实现（练手）

五、Spring入门案例：DI(掌握)

六、Spring的核心API（了解）

七、装配Bean:基于XML

一、Bean的种类

二、Bean的作用域

三、Bean的生命周期

Bean 的生命周期详情

四、Bean 的初始化和销毁

五、BeanPostProcessor 后防止Bean

六、依赖注入Bean 的属性(xml)

构造土办法

setter土办法

猜你喜欢

pk10交流群_ 用微波炉还有不少小窍门

2分飞艇app软件_洗涤白色帆布鞋的小窍门

极速十分快三稳赢计划_青岛中石化输油管道泄漏爆炸案宣判 14人被判刑

好运快3技巧稳赚方法_台风天放气球：上海台风研究所野外观测团队在台风“利奇马”登陆期间选择“逆风而行”

分分飞艇官方网站登录_赵薇30亿收购万家文化被上交所问询或披露其财产状况

3分pk10官方网址 _匹马行天下之思维决定高度篇——“大学再努力，培训机构做兄弟”姊妹篇

3分pk10手机版ios _2018年中国在线视频市场年度报告

2分彩app软件_花千骨收视爆棚赵丽颖演绎最萌古装造型【星榜样】