大发1分彩注册_Java匹马行天下之J2EE框架开发——Spring—>用IDEA开发Spring程序(01)

  • 时间:
  • 浏览:0
  • 来源:蚂蚁资源网_提供小邝娱乐网技术_QQ粉丝网资讯

一、创建项目

*注:在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另有有另另1个对象即可。即:`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/801/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 :是另有有另另1个,继承。
  • has a:有另有有另另1个,成员变量,依赖。
 class B {
       private A a;   // B类依赖A类,B类使用A类。
    }

    依赖:另有有另另1个对象都还可不可以

使用从前对象。
    注入:通过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/801/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实例。

运行后控制台显示结果

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

六、Spring的核心API(了解)

 

api整体了解即可,但是不使用,在学习过程都还可不可以 。

  • BeanFactory :这是另有有另另1个工厂,用于生成任意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,上端都还可不可以

另有有另另1个Resource,该Resource又是另有有另另1个接口,都还可不可以

找它的实现类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/801/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/801/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时,运行上端的测试代码会出显另有有另另1个问题图片图片: java.lang.IllegalArgumentException,

问题图片图片防止链接:使用Junit测试另有有另另1个 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/801/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 :是另有有另另1个特殊的bean,具有工厂生成对象能力,否则必须生成特定的对象。

      愿意生产对象的bean 都还可不可以 实现FactoryBean 接口,此接口提供土最好的土办法getObject(); 用于获得特定bean。

      • 示例:< bean id="xxx" class="FB">,这句代码的意思是:Spring会先创建FB实例,否则调用getObject(); 土最好的土办法,并返回土最好的土办法的返回值。

        即为宜如下两行代码:FB fb = new FB();return fb.getObject();

    • BeanFactory 和 FactoryBean 对比?

      • BeanFactory :是另有有另另1个生产bean的工厂,用于生成任意的bean。
      • FactoryBean :是另有有另另1个特殊的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() 将获得另有有另另1个实例。例如:在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/801/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@66480dd7

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/801/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的实例个数必须另有有另另1个)即bean中的scope配置成默认即可。

// 肯能此close土最好的土办法在接口 ApplicationContext 中这麼定义,而在实现类中提供了该土最好的土办法,大伙儿儿可不都还可不可以 使用反射,肯能反射最后执行的所以实现类中的土最好的土办法。

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


  • 五、BeanPostProcessor 后防止Bean

  • 是由spring提供的并全部都是机制,假使 实现类实现此接口BeanPostProcessor,并将该实现类提供给spring容器,spring容器将自动执行另有有另另1个土最好的土办法:在初始化土最好的土办法前执行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是大伙儿儿的目标对象,此时大伙儿儿的目标对象必须另有有另另1个接口,这麼大伙儿儿的代理对象也必须另有有另另1个接口
        // 生成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/801/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的实例个数必须另有有另另1个)即bean中的scope配置成默认即可。

// 肯能此close土最好的土办法在接口 ApplicationContext 中这麼定义,而在实现类中提供了该土最好的土办法,大伙儿儿可不都还可不可以 使用反射,肯能反射最后执行的所以实现类中的土最好的土办法。

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

}

}
    • 运行结果截图:

    • 问题图片图片1:后防止bean作用某另有有另另1个目标类,还是所有目标类?

      答:所有。
    • 问题图片图片2:怎么只作用另有有另另1个?

      答:通过获取"参数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/801/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/801/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 

猜你喜欢

时时彩高手计划_付费培育、内容深耕与产品创新 推动腾讯音乐第二季度财务和运营表现强劲

(中国深圳)时时彩高手计划20时时彩高手计划19年8月13日,腾讯音乐娱乐集团(以下简称“腾讯音乐”、“TM时时彩高手计划E”或“公司”)(纽约证券交易所股票代码:TME)发布

2020-02-23

时时彩平台代理_不一样的体位 《暗黑神域》人兽合一战天下

 3DPVP暗黑风网游《暗黑时时彩平台代理神域》不删档首测正在火热进行中。而在众多游戏特色中,三栖骑战一直是《暗黑神域》的一大亮点,不同于传统网游的单人作战模式,《暗黑神域》首

2020-02-23

2分快3豹子_粉丝运营前驱IP,天猫粉丝圈助力天猫旗舰店2.0时代开启

天猫粉丝圈无疑是天猫从流量到人群运营的重要一环。在6月25日天猫旗舰店2.0升级大会上,天猫就曾公布将通过工具2分快3豹子和产品的升级,帮助品牌商家更好地运营消费者,以持续获得

2020-02-23

秒速飞艇开户_古天乐宣萱《犯罪现场》将上线 古天乐用布包着宣萱的头向墙上撞

近日,谢安琪在香港红馆举办演唱会,期间大屏幕上播放了一段古天乐的视频短片,古仔出先刚刚,客串了一次财经新闻的主播讲起了股市,现场观...近日,谢安琪在香港红馆举办演唱会,期间大

2020-02-23