當前位置：首頁 > 前端技术 > javascript >内容正文

javascript

Spring中的p标签(转)good

發布時間：2025/3/18 javascript 15 豆豆

生活随笔收集整理的這篇文章主要介紹了 Spring中的p标签(转)good 小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

Spring的p標簽是基于XML Schema的配置方式，目的是為了簡化配置方式。

在XML文件頭部添加xmlns:p="http://www.springframework.org/schema/p"即可使用。(在Spring之后的版本中，p標簽已經包含到namespace "http://www.w3.org/2000/xmlns/"中了)

例如：

類Person

public class Person {private int age;private Tool tool;public void setAge(int age){this.age=age;}public void setTool(Tool tool){this.tool=tool;} 其余代碼省略 ...... }

原本的bean配置為

<?xml version="1.0" encoding="GBK"?> <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-3.0.xsd"><bean id="person" class="com.myclass.Person"><property name="age" value="21"/><property name="tool" ref="tool"/></bean> </beans>

使用P標簽的配置為

<?xml version="1.0" encoding="GBK"?> <beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:p="http://www.springframework.org/schema/p"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"><bean id="person" class="com.myclass.Person" p:age="21" p:tool-ref="tool"/> </beans>

http://blog.csdn.net/spirit23k/article/details/8214765

I've created a project with spring mvc and in my?dispatcherServlet.xml?file

p:prefix?and?p:suffix?are not allowed. How can I solve this issue? I've used SpringVersion?3.2.3.RELEASE

You need to add the p-namespace declaration:?xmlns:p="http://www.springframework.org/schema/p"

See Spring reference:?Chapter 5.4.2.6 XML shortcut with the p-namespace

http://docs.spring.io/spring/docs/3.2.x/spring-framework-reference/html/beans.html#beans-p-namespace

XML shortcut with the p-namespace

The p-namespace enables you to use the?bean?element's attributes, instead of nested?<property/>?elements, to describe your property values and/or collaborating beans.

Spring 2.0 and later supports extensible configuration formats?with namespaces, which are based on an XML Schema definition. The?beans?configuration format discussed in this chapter is defined in an XML Schema document. However, the p-namespace is not defined in an XSD file and exists only in the core of Spring.

The following example shows two XML snippets that resolve to the same result: The first uses standard XML format and the second uses the p-namespace.

The example shows an attribute in the p-namespace called email in the bean definition. This tells Spring to include a property declaration. As previously mentioned, the p-namespace does not have a schema definition, so you can set the name of the attribute to the property name.

This next example includes two more bean definitions that both have a reference to another bean:

As you can see, this example includes not only a property value using the p-namespace, but also uses a special format to declare property references. Whereas the first bean definition uses?<property name="spouse" ref="jane"/>?to create a reference from bean?john?to bean?jane, the second bean definition uses?p:spouse-ref="jane"?as an attribute to do the exact same thing. In this case?spouse?is the property name, whereas the?-ref?part indicates that this is not a straight value but rather a reference to another bean.

Note


	The p-namespace is not as flexible as the standard XML format. For example, the format for declaring property references clashes with properties that end in?Ref, whereas the standard XML format does not. We recommend that you choose your approach carefully and communicate this to your team members, to avoid producing XML documents that use all three approaches at the same time.

XML shortcut with the c-namespace

Similar to the?the section called “XML shortcut with the p-namespace”, the?c-namespace, newly introduced in Spring 3.1, allows usage of inlined attributes for configuring the constructor arguments rather then nested?constructor-arg?elements.

Let's review the examples from?the section called “Constructor-based dependency injection”?with the?c?namespace:

The?c:?namespace uses the same conventions as the?p:?one (trailing?-ref?for bean references) for setting the constructor arguments by their names. And just as well, it needs to be declared even though it is not defined in an XSD schema (but it exists inside the Spring core).

For the rare cases where the constructor argument names are not available (usually if the bytecode was compiled without debugging information), one can use fallback to the argument indexes:

<-- 'c-namespace' index declaration --> <bean id="foo" class="x.y.Foo" c:_0-ref="bar" c:_1-ref="baz"> Note


	Due to the XML grammar, the index notation requires the presence of the leading?_?as XML attribute names cannot start with a number (even though some IDE allow it).

In practice, the constructor resolution?mechanism?is quite efficient in matching arguments so unless one really needs to, we recommend using the name notation through-out your configuration.

Compound property names

You can use compound or nested property names when you set bean properties, as long as all components of the path except the final property name are not?null. Consider the following bean definition.

The?foo?bean has a?fred?property, which has a?bob?property, which has a?sammy?property, and that final?sammy?property is being set to the value?123. In order for this to work, thefred?property of?foo, and the?bob?property of?fred?must not be?null?after the bean is constructed, or a?NullPointerException?is thrown.

5.4.3?Using?depends-on

If a bean is a dependency of another that usually means that one bean is set as a property of another. Typically you accomplish this with the?<ref/>?element?in XML-based configuration metadata. However, sometimes dependencies between beans are less direct; for example, a static initializer in a class needs to be triggered, such as database driver registration. The?depends-on?attribute can explicitly force one or more beans to be initialized before the bean using this element is initialized. The following example uses the?depends-on?attribute to express a dependency on a single bean:

To express a dependency on multiple beans, supply a list of bean names as the value of the?depends-on?attribute, with commas, whitespace and semicolons, used as valid delimiters:

<bean id="beanOne" class="ExampleBean" depends-on="manager,accountDao"> <property name="manager" ref="manager" /> </bean> <bean id="manager" class="ManagerBean" /> <bean id="accountDao" class="x.y.jdbc.JdbcAccountDao" /> Note


	The?depends-on?attribute in the bean definition can specify both an initialization time dependency and, in the case of?singleton?beans only, a corresponding destroy time dependency. Dependent beans that define a?depends-on?relationship with a given bean are destroyed first, prior to the given bean itself being destroyed. Thus?depends-on?can also control shutdown order.

5.4.4?Lazy-initialized beans

By default,?ApplicationContext?implementations eagerly create and configure all?singleton?beans as part of the initialization process. Generally, this pre-instantiation is desirable, because errors in the configuration or surrounding environment are discovered immediately, as opposed to hours or even days later. When this behavior is?notdesirable, you can prevent pre-instantiation of a singleton bean by marking the bean definition as lazy-initialized. A lazy-initialized bean tells the IoC container to create a bean instance when it is first requested, rather than at startup.

In XML, this behavior is controlled by the?lazy-init?attribute on the?<bean/>?element; for example:

When the preceding configuration is consumed by an?ApplicationContext, the bean named?lazy?is not eagerly pre-instantiated when the?ApplicationContext?is starting up, whereas the?not.lazy?bean is eagerly pre-instantiated.

However, when a lazy-initialized bean is a dependency of a singleton bean that is?not?lazy-initialized, the?ApplicationContext?creates the lazy-initialized bean at startup, because it must satisfy the singleton's dependencies. The lazy-initialized bean is injected into a singleton bean elsewhere that is not lazy-initialized.

You can also control lazy-initialization at the container level by using the?default-lazy-init?attribute on the?<beans/>?element; for example:

http://www.cnblogs.com/huey/p/4507122.html

轉載于:https://www.cnblogs.com/softidea/p/5561010.html

總結

以上是生活随笔為你收集整理的Spring中的p标签(转)good的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。