SOURCE Snapshot:
Https://git.oschina.net/tinyframework/tiny
Before you get started, the default is already familiar with Maven and git, for Maven and gig-related issues, girls ask Google, boys ask degrees Niang, his two-bit meticulous patience will make you satisfied.
Before install, you need to prepare the environment to confirm that your machine can be sisu or have a good maven agent.
Make sure that there are jdk1.5 and more than 1.6 versions in the compilation environment.
Add the following configuration to your Maven settings.xml:
Add the following to the <profiles> Note: The file path should be changed to match your actual situation.
1
2
3
4
5
6
7 |
<profile>
<id>JAVA_CONFIG</id>
<properties>
<java_1_5_javac>c:\program files\java\jdk1.5.0_22\bin\javac</java_1_5_javac>
<java_1_6_javac>c:\program files\java\jdk1.6.0_45\bin\javac</java_1_6_javac>
</properties>
</profile> |
Add the following content to the <activeProfiles> section:
| 1 |
<activeProfile>JAVA_CONFIG</activeProfile> |
then, execute the following command in the directory where the root pom is located:
| 1 |
<strong>maven install-dskiptests</strong> |
Under normal circumstances, MAVEN will download something and then start the installation, and the successful installation will indicate that the environment is built. For more information, please see my blog.
The tiny framework is a 10-minute starter for 10 minutes to give the reader an overview of the composition of the tiny framework.
- Application Configuration Framework
Used to provide system configuration load and distribution, while providing the default configuration and application-level configuration two sets of configuration scenarios, and the application-level configuration is the main, that is, application-level configuration parameters can override the default configuration.
The advantage of doing this is that if you do not configure application-level configuration, the default configuration can also be good for you, and if you provide an application-level configuration, you can personalize the original behavior of the system, framework, and module. Provides a balance between personalization and ease of access. If it is a low-level user, then you use the fool, what configuration also do not change, it may not be optimal, but it must be quite good; If you are an advanced customer, you can configure various parameters in depth.
- App Launch
Whether it's a normal console app or a web app, there's a startup process. Application startup is used to load the configuration, distribute the configuration, start the file scan, start the plugin framework, and so on. This generally uses the default implementation, of course, if you want to further adjust the startup mode, you can also implement it yourself.
- File scanning
The tiny framework uses a combination mode that is thrown in and out of the tube, and is actually implemented by scanning and processing a file scanner. It can be said that file scanning is the cornerstone of modularity.
- Plugin Framework
The plug-in framework mainly addresses start-up and stop, as well as the start and stop timing. The first version of the plug-in framework is to support hot-swappable, but due to the problems and more to consider, the input-output ratio is too non-economic, another because the tiny framework is an SOA architecture pattern, so can be separated by different machines in the cluster maintenance to solve the problem of hot plugging, so now to non-hot plug-in mode.
- General Event Processing Framework
The generic event processing plug-in is used to provide unified, service-based access to the outside, regardless of where the real producer of the service is, so it doesn't matter what the local and remote services are.
- Service Loading Framework
The service load framework is used to load services in the local runtime environment and register them in the Common event processing framework.
- Buffer frame
By finding out if there are buffering implementations, if any, and loaded and started.
- UI engine
The UI engine is used to find and load the UI components that exist in the current running environment, and provides related processing such as JS merging and CSS merging. It also provides powerful layout and page-based presentation support. At the same time, the high level of component makes it easy to reuse other people's components as well as to develop components themselves. It also provides the processing of JS,CSS load sequencing, which allows developers to take care of these ingestion order issues.
- JSP Run engine
JSP run engine is improved by the Jasper engine, the main improvement is to solve the problem of modularization, that is to put the JSP into the jar package support.
- Dictionary Framework
The dictionary framework is used to load dictionary entries used in the system through various loading methods and to provide dictionary services to the outside.
- DBF file Read
All field types except the M,B,G type are currently supported and are subsequently added to the DBF file because there is no demand for the time being.
- INI file read and write
Support INI file read/write, duplicate attribute name in same paragraph
- Context Support
Provides strong context support, enabling context nesting. With context support, the replication of variables only occurs across nodes. It saves system overhead, memory footprint, and simplifies the implementation of the framework.
- Document Generation Framework
Used to generate various types of text content, such as: XML, such as: source code, such as: Word,pdf,excel and so on. Of course, it's just a framework, with some components embedded in it, but it's really good to use, or you need to expand the component.
- VFS Virtual File system
It is used to unify the encapsulation of files with various heterogeneous file sources, supports the unified access of local files, URL files, ftp files, zip,jar files, etc., and can also support more file sources by extension.
- Basic components
It mainly includes thread group, object pool, priority queue and so on.
- Meta-Data loading framework
Supporting the definition of various metadata and loading it, the metadata mainly contains type definition (shielding different database and programming language differences), business type definition (make business type has meaning), standard field definition (only use standard field in business) and so on, through the definition of these metadata, can be easily cross-database, Run across programming languages (only for process orchestration development).
- Database access Framework
Tiny framework itself does not reject any ORM scheme, but embedded also adds a small cross-database data access scheme, do not write Pojo, do not write DAO, directly can complete a variety of database processing. And can be integrated with frameworks such as Hibernate,ibatis.
- Application Installation Framework
Application installation framework to solve the software upgrade process of database table structure adjustment, initialization of data insertion and so on, no matter how many version changes experienced, can make the application without workload automatic upgrade completed. People who have had a large engineering experience will know how much convenience this feature can bring and how much development and maintenance work the node has.
- XML and HTML parsing
Embedded high-performance XML and HTML parsing, especially in terms of traversal performance is much higher than the general parser, and is well suited for scenarios that require a lot of traversal after a parse. At the same time, for Chinese labels and attributes have good support, there is very strong fault tolerance, even if the HTML does not conform to the specification, most of the situation can be correctly parsed. The worst case scenario would also give an incorrect DOM, instead of throwing out the wrong one.
- Web crawler Support
Resource acquisition integrated httpclient,html parsing using embedded HTML parsing scheme, easy to use, can avoid multiple crawls, dead loops and so on, in the general application scenario is enough.
- Process engine
Support components arbitrarily extensible, support object-oriented features, such as: Process inheritance, node overwrite overrides, and provide a flexible exception capture mechanism, but also support process re-entry, that is, the execution of the process is not necessarily from the first node of the process execution. The workflow engine is theoretically possible, but has not yet started, because of the ability of the process to re-enter, based on its support for page flow.
- Calibration Framework
Provide pre-and post-check rules for one-time writing, both front and back.
- Web Layer Box Plus
This one offers too much content, not necessarily full. Support for Web. XML does not modify the scheme, which greatly facilitates modularity and later maintenance. Provides page flow support. Provides rewrite support. File upload support is available. Provides security filtering. No session support is provided. Provides bigpipe support. Provides compression output support. Provides object assembly support.
- Dbrouter
Based on the JDBC3 and JBC4 specification, the database cluster and sub-Library sub-table scheme provides strong support for database cluster, sub-library, and table, and supports various databases. SQL statements that are outside the bounds can be supported. The database cluster and sub-Library sub-table scheme with minimal impact on the upper application.
- Distributed computing Framework
It provides multi-machine cooperative distributed computing function based on the job reference, foreman, worker and working mode. Support task decomposition, merging, support work serialization, never lose, and many other features.
Open source framework Tiny content composition
