Spring bean mod02

Containing your beans-1
 The container is at the core of the Spring
Framework
 Framework. Spring’s container uses
 dependency injection (DI) to manage the
components that make up an application.
 This includes creating associations between
collaborating components
 Spring comes with several container
 implementations that can be categorized
into two distinct types

Containing your beans-2
 Bean factories (defined by the
org.springframework.beans.factory.
BeanFactory interface) are the simplest of
containers

Introducing the BeanFactory
 As its name implies, a bean factory is an
implementation of the Factory design
pattern. That is, it is a class whose
responsibility is to create and dispense beans
 There are several implementations of
BeanFactory in Spring. But the one that is
most commonly used is
org.springframework.beans.factory.xml.
XmlBeanFactory, which loads its beans based on
the definitions contained in an XML file.

Lab-Entity Class(JavaBean Class)
Implements-1
 規劃一個打招呼的介面interface
/method

Lab-Entity Class(JavaBean Class)
Implements-2

Introducing the BeanFactory
 There’s more to a bean factory than simply
instantiation and delivery of application
objects. Because a bean factory knows about
many objects within an application,it is able
to create associations between collaborating
objects as they are instantiated.
 There are several implementations of
BeanFactory interface in Spring.
 But the one that is most commonly used is
org.springframework.beans.factory.xml.
XmlBeanFactory

<bean> element
 <bean id=“bean識別名稱”
class=“JavaBean class”>
 <property name=“setter名稱” value=“屬
性值”/>

Lab classpath 參考相對的類別庫
 建立lib資料夾
 匯入commons.logging-1.1.1-bin.jar/spring-
beans.jar/spring-context.jar/spring-
core.jar
 Classpath設定

Test Spring bean Main Program
 This simple line of code tells the bean
factory to read the bean definitions from
the XML file
 But the bean factory doesn’t instantiate
the beans just yet

Bean Instance
 When getBean() is called, the factory will
instantiate the bean and set the bean’s
properties using DI.

Working with
an application context
 A bean factory is fine for simple
applications, but to take advantage of the
full power of the Spring Framework, you’ll
probably want to load your application
beans using Spring’s more advanced
container: the application context.

application context?
 But an ApplicationContext offers much
more…
 Application contexts provide a means for
resolving text messages, including support
for internationalization (I18N) of those
messages.
 Application contexts provide a generic way
to load file resources, such as images.
 Application contexts can publish events to
beans that are registered as listeners.

ApplicationContext
are three that are commonly used
 ClassPathXmlApplicationContext
◦ Loads a context definition from an XML file
located in the classpath, treating context
definition files as classpath resources.
 FileSystemXmlApplicationContext
◦ Loads a context definition from an XML file in
the file system.
 XmlWebApplicationContext
◦ Loads context definitions from an XML file
contained within a web application.

FileSystemXmlApplicationContxt
架構

Implements-
FileSystemXmlApplicationContext

FileSystemXmlApplicationContext
Demo

Injecting through constructors
 the xxx class can be constructed in two
different
 ways:
 ■ Using the default constructor
 ■ Using a constructor that takes an int
argument that indicates the number of
beanbags that the xxxx class

Config constructor Injection-1
 Implements Class

Config constructor Injection-2

Constructor Injeciton Main
Programming

Referencing other beans
 Kenny’s a very talented instrumentalist
and can play virtually any instrument given
to him.
 As long as it implements the Instrument
interface

Bean config
 Before we can give Kenny a saxophone to
play, we must declare it as a <bean> in
Spring. The following XML should do:

 With the saxophone declared, we’re
ready to give it to Kenny to play. The
following modification to the kenny bean
uses setter injection to set the instrument
property:

Referencing Bean Lab-1
 Employee aggregation Working class
 Define Working Class
 Work interface

 Define Employee class aggregation
Working class

 Spring bean config

Injecting inner beans
 We’ve seen that Kenny is able to play
saxophone, piano, or any instrument that
implements the Instrument interface. But
what’s also true is that the saxophone and
piano beans could also be shared with any
other bean by injecting them into an
Instrument property.

Wiring collections
 use Spring to configure both simple
property values (using the value attribute)
and properties with references to other
beans (using the ref attribute).
 Spring offers four types of collection
configuration elements that come in
handy when configuring collections of
values

Collection four types
 As for <map> and <props>, these two
elements correspond to collections that
are java.util.Map and java.util.Properties
 The <list> and <set> elements are useful
when configuring properties that are
either arrays or some implementation of
java.util.Collection

Spring Collection
 Hank’s special talent is that he is a one-
man band. Like Kenny, Hank’s talent is
playing several instruments, but Hank can
play several instruments at the same time

Lists and arrays
 To give Hank a collection of instruments
to perform with, let’s use the <list>
configuration element:

Collection Lab-1
 一個員工同時間可以進行多樣工作…
 規劃一個可以從事多項工作的
ChtEmployee Entity Class

Collection Lab-2
 Config配置

Wiring nothing (null)
 you will use DI to wire a value or an
object reference into a bean’s properties.
But what if you want to ensure that a
property is null?
 some beans may themselves set a
property to a non-null default value
 To set a property to null, you simply use
the <null/> element. For example

Spring bean mod02

Recommended

More Related Content

What's hot (18)

Viewers also liked (20)

Similar to Spring bean mod02 (20)

More from Guo Albert (20)

Recently uploaded (20)

Spring bean mod02