Shulou(Shulou.com)06/03 Report--

MyBatis's XML configuration file contains settings and property information that have a profound impact on MyBatis behavior. XML document

The high-level structure is as follows:

Configuration configuration properties properties settings settings typeAliases type naming typeHandlers type processor objectFactory object factory plugins plug-in environments environment variables transactionManager transaction manager dataSource data source mapper

Properties

These are externalized, replaceable attributes that can also be configured in a typical Java attribute configuration file or passed through child elements of the properties element.

For example:

The properties can be used throughout the configuration file, using replaceable properties for dynamic configuration.

For example:

Properties will be replaced from the values in the included jdbc.properties file.

Settings

The following table describes the settings information, their meaning, and default values.

An example of setting information elements, the full configuration is as follows:

TypeAliases

A type alias is a short name for the Java type. It is only relevant to the XML configuration and is only used to reduce the excess of the fully qualified name of the class.

For example:

With this configuration, "User" can be used as an alternative to where "com.mu.mybatis.domain.User" is used.

TypeHandlers

Whether MyBatis sets a parameter in a preprocessing statement or fetches a value from the result set, the type handler is used to convert the obtained value to the Java type in an appropriate manner. The following table describes the default type processor.

You can rewrite type handlers or create your own type handlers to handle unsupported or non-standard types. To do this, simply implement the TypeHandler interface (org.mybatis.type), then map the new type handler class to the Java type, and optionally a JDBC type. For example:

/ / ExampleTypeHandler.javapublic class ExampleTypeHandler implements TypeHandler {public void setParameter (PreparedStatement ps, int I, Object parameter,JdbcType jdbcType) throws SQLException {ps.setString (I, (String) parameter);} public Object getResult (ResultSet rs, String columnName) throws SQLException {return rs.getString (columnName);} public Object getResult (CallableStatement cs, int columnIndex) throws SQLException {return cs.getString (columnIndex);}} / MapperConfig.xml

Using such a type handler will override existing type handlers that handle Java's String type properties and VARCHAR parameters and results. Note that MyBatis does not look at the database meta-information to decide which type to use, so you must specify the field of type VARCHAR in the parameter and result mapping to bind to the correct type handler. This is due to the fact that MyBatis does not know the data type until the statement is executed.

ObjectFactory

Each time MyBatis creates a new instance of the resulting object, it uses an instance of ObjectFactory. If a parameter mapping exists, the default ObjectFactory does no more than instantiating the target class using the default constructor or constructor with parameters. If you want to override the default ObjectFactory, you can create your own.

For example:

/ / ExampleObjectFactory.javapublic class ExampleObjectFactory extends DefaultObjectFactory {public Object create (Class type) {return super.create (type);} public Object create (Class type,List constructorArgTypes,List constructorArgs) {return super.create (type, constructorArgTypes, constructorArgs);} public void setProperties (Properties properties) {super.setProperties (properties);}} / / MapperConfig.xml

The ObjectFactory interface is very simple. It contains two methods for creation, one is the default constructor, and the other is to deal with constructors with parameters. Finally, the setProperties method can be used to configure ObjectFactory. After initializing your ObjectFactory instance, the properties defined in the body of the objectFactory element are passed to the setProperties method.

Plugins

MyBatis allows you to intercept calls executed by mapped statements at some point.

By default, MyBatis allows the use of plug-ins to intercept method calls:

Executor

(update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)

ParameterHandler

(getParameterObject, setParameters)

ResultSetHandler

(handleResultSets, handleOutputParameters)

StatementHandler

(prepare, parameterize, batch, update, query)

The details of the methods in these classes can be found by looking at the signature of each method, and their source code exists in the MyBatis distribution. You should understand the behavior of the methods you override, assuming that you are doing more than monitoring calls.

If you try to modify or override a given method, you may break the core of MyBatis. These are low-level classes and methods, and plug-ins should be used with caution.

Using plug-ins is the very simple power they provide. Simply implement the interceptor interface to determine the specified signature you want to intercept.

/ ExamplePlugin.java@Intercepts ({@ Signature (type= Executor.class,method = "update", args = {MappedStatement.class,Object.class})}) public class ExamplePlugin implements Interceptor {public Object intercept (Invocation invocation) throws Throwable {return invocation.proceed ();} public Object plugin (Object target) {return Plugin.wrap (target, this);} public void setProperties (Properties properties) {}} / / MapperConfig.xml

The above plug-in will intercept all "update" method calls in the Executor instance, which is also the internal object responsible for the execution of low-level mapping statements.

Environments

MyBatis can be configured in a variety of environments. This will help you apply SQL mapping to a variety of databases. For example, you may want to set up different configuration, test, and production environments for development. Or you may have multiple production databases but share the same schema, so you may want to use the same SQL mapping for different databases. There are many such use cases.

One important thing to remember: you can configure multiple environments, but you can only choose one for each SqlSessionFactory instance.

So, if you want to connect to two databases, you need to create two SqlSessionFactory instances, one for each database. If there are three databases, you need three instances, and so on. It's easy to remember:

Each database corresponds to a SqlSessionFactory to determine which environment to create, you can pass it to SqlSessionFactoryBuilder as an optional parameter.

The two method signatures that can accept environment configuration are:

SqlSessionFactory factory = sqlSessionFactoryBuilder.build (reader, environment); SqlSessionFactory factory = sqlSessionFactoryBuilder.build (reader, environment,properties)

If the environment is ignored, the default environment will be loaded as follows:

SqlSessionFactory factory = sqlSessionFactoryBuilder.build (reader); SqlSessionFactory factory = sqlSessionFactoryBuilder.build (reader,properties)

The environment element defines how to configure the environment.

Note the key parts here:

Default environment ID (for example: default= "development"). The environment ID defined by each environment element (for example: id= "development"). Configuration of the transaction manager (for example: type= "JDBC").

TransactionManager

There are two types of transaction managers in MyBatis (that is, type= "[JDBC | MANAGED]"):

JDBC-this configuration simply uses JDBC's commit and rollback settings. It relies on connections from the data source to manage the transaction scope.

MANAGED-this configuration does little. It never submits or rolls back a connection. It allows the container to manage the entire lifecycle of the transaction (such as the context of the Spring or JEE application server). By default, it closes the connection. However, some containers don't want this, so if you need to stop it from the connection, set the closeConnection property to false.

DataSsource

The dataSource element uses the basic JDBC data source interface to configure the resources of the JDBC connection object. Many MyBatis applications will configure the data source as shown in the example. However, it is not necessary.

Be aware that data sources are necessary in order to facilitate the use of deferred loading.

There are three built-in data source types (that is, type=):

UNPOOLED-the implementation of this data source is to simply open and close the connection each time it is requested. It's a little slow.

This is a good choice for simple applications because it does not require timely available connections. Different databases for this

The performance is also different, so it is not important to configure the data source for some databases, and this configuration is idle.

Data sources of type UNPOOLED are only used to configure the following five properties:

Driver-this is the fully qualified name of the JDBC-driven Java class

Url-this is the JDBC URL address of the database

Username-user name to log in to the database

Password-password to log in to the database

DefaultTransactionIsolationLevel-default connection transaction isolation level

Optionally, you can pass database-driven properties. To do this, the property is prefixed with "driver." Open

Head, for example:

Driver.encoding=UTF8

This passes the "encoding" attribute with the value "UTF8", which is passed to the database driver through the DriverManager.getConnection (url,driverProperties) method.

POOLED-this is the implementation of data source connection pooling for JDBC connection objects to avoid the initial connection and authentication time necessary to create new connection instances. This is a popular method used by current Web applications to respond to requests quickly.

In addition to the properties above (UNPOOLED), there are many properties that can be used to configure POOLED data sources:

PoolMaximumActiveConnections-the number of active (that is, in use) connections that exist at any time. Default value: 10

PoolMaximumIdleConnections-the number of idle connections that exist at any time.

PoolMaximumCheckoutTime-the time that connections in the pool are checked before being forced to return. Default: 20000 milliseconds (that is, 20 seconds)

PoolTimeToWait-this is a low-level setting that gives the connection pool a chance to print log status, and retries to get the connection, which often takes a long time (to avoid silent failure when the connection pool is not configured). Default: 20000 milliseconds (that is, 20 seconds)

PoolPingQuery-A probe query sent to the data to verify that the connection is working properly and is ready to accept the request. The default is "NO PING QUERY SET", which causes many database-driven connections to fail due to an error message.

PoolPingEnabled-this turns snooping queries on or off. If enabled, you must set the poolPingQuery property with a valid SQL statement. Default value: false.

PoolPingConnectionsNotUsedFor-this is used to configure poolPingQuery multiple times to be used once. This can be set to match the standard database connection timeout to avoid unnecessary detection. The default value is 0 (that is, all connections are detected at every moment-but only if poolPingEnabled is true).

JNDI-this data source is implemented to use a container such as Spring or an application server, which can centrally or externally configure the data source and then place a reference to the JNDI context. This data source configuration requires only two properties:

Initial_context-this attribute is used to find the environment in the following text from the beginning. This is an optional attribute, and if it is ignored, the data_source attribute will be looked again directly against the background of initialContext.

Data_source-this is the path to the context that references the location of the data source instance. It looks in the context returned by the initial_context query, or directly in the initial context if the initial_context does not return a result.

Similar to other data source configurations, it can also be configured through the name "env." Sends the attribute directly to the initial context

Env.encoding=UTF8

After initialization, this passes a property named "encoding" to the constructor of the initial context with the value "UTF8".

Mappers

Now that the behavior of MyBatis has been configured by the above elements, we now need to define the SQL mapping statement. But first we need to tell MyBatis where to find these statements. Java doesn't provide a good way to do this, so the best way is to tell MyBatis where to find the mapping file.

These statements simply tell MyBatis to go to the × × × mapping file.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.