秒秒快3网游_Java匹马行天下之J2EE框架开发——Spring—>用IDEA开发Spring程序(01)

  • 时间:
  • 浏览:0
  • 来源:小刀娱乐网_提供QQ爱好者技术_UU资源网资讯

一、创建项目

*注:在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/2001/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/2001/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/2001/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/2001/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/2001/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/2001/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@664200dd7

System.out.println(userService2);

//service.UserServiceImpl@52a86356

}

}
  • 三、Bean的生命周期

Bean 的生命周期详情

  1. instantiate bean 对象实例化。
  2. populate properties 封装属性。
  3. 不可能 Bean实现 BeanNameAware,则表示执行 setBeanName
  4. 不可能 Bean实现 BeanFactoryAware 不可能 ApplicationContextAware,则表示设置实例工厂(setBeanFactory)不可能 上下文对象(setApplicationContext)。
  5. 不可能 趋于稳定类实现 BeanPostProcessor(后解决Bean),则表示执行 postProcessBeforeInitialization
  6. 不可能 Bean实现 InitializingBean,则表示执行 afterPropertiesSet
  7. 调用,则表示指定初始化最好的方法 init
  8. 不可能 趋于稳定类实现 BeanPostProcessor(解决Bean),则表示执行 postProcessAfterInitialization
  9. 执行业务解决
  10. 不可能 Bean实现 DisposableBean,则表示执行 destroy
  11. 调用 ,则表示指定销毁最好的方法 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/2001/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/2001/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/2001/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/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 

猜你喜欢

飞艇正规网_中医食疗缓解婴幼儿消化

婴幼儿飞艇正规网的脾胃娇嫩,常常或者家庭的喂养不当,飞艇正规网小儿乳食控制不好,再加过食生冷,容易伤到孩子的脾胃,或者胃腑对食物不到充分的消化吸收,以致水谷不分,走入大肠,会造

2019-12-13

腾讯1.5分彩外挂_错误认识浓茶利尿适醒酒

其他人常会用腾讯1.5分彩外挂浓茶腾讯1.5分彩外挂来解酒,以为喝醉酒后喝些茶利于排尿,从而也就将工业正己烷排除体外。随后 实际上,本身做法是不可取的。用浓茶解酒从不到达到最

2019-12-13

秒速pk10外挂_国外护理人员提供的生活妙招,跟着学起来!

掌握了就说生活小办法,还需用处置生活中就说小问题。今天生活办法网小编和亲们分享的是由国外专业的“护理人员”所提供的生活办法,同時 来看看吧!1、薄荷味还需用除臭可能性秒速pk

2019-12-13

秒速pk10规律_豆浆营养高,但这4类人不宜饮用!

豆浆价格便宜营养高老要 深受许秒速pk10规律多人喜爱,但有专家提醒不宜空腹喝豆浆,而且 肠胃虚寒、手术、产后和大病初愈的患者却说适合饮用不要 豆浆。有营养师指出,豆浆中

2019-12-13

5分飞艇官网注册码_上班久坐族必备的6种蔬菜

办公室一族习惯久坐于办公桌前,愿因 肠道蠕动不充分,全都办公室男人的女人的女人都不 便秘的烦恼,将会在平时饮食中有 意识地多选折 下面几种蔬菜,也能起到十分有效的通便效5

2019-12-13