Simplified spring (1)-configuration file

Everyone loves spring and hibernate.
However, the sample code of spring MVC + hibernate, such as appfuse, cannot be the most concise, elegant, and easy to read. If we continue to use the best sample painting method in our own projects, good wishes may not be fulfilled.
Therefore, the spirit of pramatic will not go off. This series is to find the most suitable spring + hibernate mode.

I-Simplified configuration file

I'm tired of all the frameworks with heavy configuration files.
The best case is,The Framework provides extremely flexible and complex configuration methods, but only when you need them
.
 
Spring provides three possibilities to simplify XML. With the improvement of domestic user level, all these basic simplification skills have been mastered.
Let's look at the Follow-up improvements of 3rd, 4th -- spring 1.2 and spring 2.0.

1.1.autowire = "byname"/"bytype"

Assuming that the controller has a property named mermerdao, spring will find the bean named customerdao in the configuration file and automatically inject the bean to the Controller.
If the bean has two attributes, one for default injection and the other for customization, you only need to set autowire and explicitly declare the one for customization. This should meet the requirements and provide configuration when special configuration is required. Otherwise, a default injection will be provided to me.

In another lazy place, write default-autovwrie = "byname" in the root <beans> node to make all beans in the file default autowrie.

Rod believes that this can be done in the development phase, but production
Autowire should not be used on the server. In my opinion, the custom location such as transcationmanager should be defined in detail, and
Dao, controller, a large number of repeated bean definitions can be stolen.

1.2. <bean> Abstract Public definitions and inner beans between nodes

This is too convenient and lazy. I cannot think of two independent XML nodes that can play with inheritance and derivation. The child node has all the attributes of the parent node.
It is best to use the Transtion proxy definition. First define a long and redundant parent class, and then inherit it with the subclass.

In addition, there is an inner bean mechanism that can write Dao as the internal class of proxy. Why write it as an internal class? In order to let the proxy impersonate it to let the Controller autowire. (For details, see the following example)

1.3. Loose configuration, to XML or not to XML

It is said that spring is much looser than struts configuration, which gives people the opportunity to recall things from the configuration file in the original code.
I do not agree to expose everything to the configuration file, resulting in a rich information configuration file. When modifying or viewing the configuration file, you must open the configuration file and the original code at the same time to understand everything.
I want the configuration file to focus on some overall configuration, as well as the redundant code required by the framework that does not need to be managed. However, for configuration and logic with little changes in some details, try not to stick it in. Therefore, we do not recommend that you configure success/fail view.

2. Simplified configuration file

1. Only one sentence left for Controller

<
Bean
Name
= "Customercontroller"
Class
= "Org. springside. Bookstore. Web. mermercontroller"
Autowire
= "Byname"
/>

2. There is only one sentence left for Dao.

<
Bean
ID
= "Customerdao"
Class
= "Org. springside. Bookstore. Dao. customerdao"
/>

3. There are only five lines left in the service class

<
Bean
ID
= "Customermanager"
Parent
= "Basetxservice"
>


<
Property
Name
= "Target"
>


<
Bean
Class
= "Org. springside. Bookstore. Service. customermanager"
/>


</
Property
>


</
Bean
>

3. Simplified XML syntax after spring 1.2

 
The main simplification is to extract the attribute values and reference beans fromSubnode
Changed backAttribute Value
It is useful for brothers who do not like autowire.
Of course, if the value requires CDATA, it must use subnodes. In addition, list values can be separated by spaces, which is more practical.

1. Attribute Value

<
Property
Name
= "Foo"
>



<
Value
>
Foovalue
</
Value
>

</
Property
>

Simplified
<
Property
Name
= "Foo"
Value
= "Foovalue"
/>

2. Reference bean <
Property
Name
= "Foo"
>



<
Ref
Bean
= "Foobean"
>


</
Property
>


Simplified

<
Property
Name
= "Foo"
Ref
= "Foobean"
/>

3. List can be simplified to a string separated by Spaces

 

<
Property
Name
= "Myfriendlist"
>



<
List
>



<
Value
> Gigix
</
Value
>

<
Value> wuyu

</
Value
>



</
List
>


</
Property
>


Simplified

<
Property
Name
= "Myfriendlist"
Value
= "Gigix wuyu"
/>

4. Spring 2.0 is coming.

If there is no external force, spring XML may not change. But now XML has become a street mouse, which is forced by ror's default configuration and jdk5's Annotation. Of course, we need to continue to make changes.
For example, some developers think that the node name must start with bean and append an attribute ID to indicate the bean name. The attribute value must create a property subnode, the sub-node has an attribute name to indicate the attribute name, which is very intuitive to the machine.

<
Bean
ID
= "Customerdao" class = "org. springside... customerdao"
>

 
<
Property
Name
= "Maxcount"
Value
= "10"
>


</
Bean
>

What you want to see should be written

<
Customerdao
Class
= "Org. springside... customerdao"
Maxcount
= "10"
/>

Spring 2.0 Implements similar syntaxes using schema. For details, see its jpetstore sample.

5. Use the DTD provided by spring to make the editor smart.

If you do not use the spring plug-in of Eclipse, you should at least use the DTD that comes with spring to make the XML editor smart, which can automatically generate attributes for you and determine whether node/attribute names are spelled incorrectly.

6. More unusual simplified configuration methods

For example, autoproxy, but I think it is more simplified and uncontrollable, so it is not used.