Projects tagged ‘ioc’, ‘java’, and ‘spring’

Spring is a lightweight Java/J2EE application framework based on code published in "Expert One-on-One J2EE Design and Development" by Rod Johnson. It includes powerful JavaBeans-based configuration ... [More] management applying Inversion-of-Control principles, a generic abstraction layer for transaction management allowing for pluggable transaction managers, a JDBC abstraction layer, integration with Hibernate, JDO, Apache OJB, and iBATIS SQL Maps, AOP functionality, and a flexible MVC Web application framework with multiple view technologies. There is also a .NET port available. [Less]

A collection of modules, add-ons and integration tools for the Spring Framework.

Spring-Annotation is a library that enables the use or annotations to configure your application using spring-framework as a backend. In the next versions it will enable the use of standard Java EE ... [More] annotations as an alternative way to configure your application, but without a need for a full Java EE 5 application server. [Less]

GWToolboxWelcome to the GWToolbox project. The GWToolbox project provides a collection of modules to help developers create robust web 2.0 / Ajax applications using the Google Web Toolkit (GWT). ... [More] Current modulesCurrently the following modules are provided: gwtoolbox-commons: A library with common utility classes which are used by other modules and can also be used by other GWT applications. This collection of utilities is largely based on common Java Open Source projects (e.g. Spring, apache commons, etc..) gwtoolbox-bean: A library that brings the power of Java bean programming to GWT applications. Constructs like PropertyDescriptor, BeanInfo, and PropertyChangeListeners can now be used and applied transparently on a simple GWT Java bean. This module also comes with bean binding and validation support. gwtoolbox-ioc: This module bring IoC to GWT applications. Heavily based on Spring, users can now define all object/widgets/components of their GWT application within Spring application context and wire them declaratively. This is now yet another Spring-like ioc container, but rather a container that can read actual Spring configuration files. This brings along many of the power tools Spring comes with: AspectJ-like AOP support, bean life-cycle management (including lazy/eager initialization), scopes (singleton/prototype), and even Spring namespaces. Users can now create proprietary namespaces for their GWT components. Modules in developmentThe following modules are currently in development: gwtoolbox-widget: A set of generic model based widget classes with concrete implementations of bean backed models. These widgets/models highly depend on the gwtoolbox-bean module. Getting startedTake a look at our Getting Started Guide to get started using GWToolbox to build better GWT applications. Quick StartTo quickly create a GWToolbox based project, you can use the following link. This will redirect you to a form which will help you create an initial maven2 project using a dedicated maven archetype: http://gwtoolboxarchetype.appspot.com [Less]

AtUnitAtUnit minimizes boilerplate code in unit tests and guides test development by enforcing good practices. mark exactly one field with @Unit to indicate the object under test. mark fields with ... [More] @Mock or @Stub to obtain mock objects inject your tests, and your test subjects, using your favorite IoC container Mock Objects IntegrationAtUnit integrates with JMock or EasyMock to provide mock objects: obtain a JMock context simply by declaring a field annotate fields with @Mock to obtain JMock or EasyMock mock objects annotate fields with @Stub to obtain a JMock or EasyMock stub object ... or you can use your own mock objects plug-in with two easy steps: implement the MockFramework interface annotate your tests with @MockFrameworkClass(MyMockFramework.class) Container IntegrationAtUnit integrates with Guice or Spring to take all of the work out of dependency-injected tests. With Guice: never see the Injector, never write bootstrapping boilerplate! @Inject test class fields without even defining a Module declaratively obtain mock objects with @Inject @Mock if you need more binding flexibility, simply have your test class implement Module With Spring: annotate fields with @Bean to get them from the Spring context fields annotated with @Bean which do not appear in your Spring context are added to it automatically! (This includes @Mock and @Stub fields.) AtUnit looks for a Spring XML file with the same name as your test, or you can specify the location yourself with @Context("filename") Most of the time, you don't even need a Spring XML file! You can easily plug in other containers in two steps: implement the Container interface annotate your tests with @ContainerClass(MyContainer.class) Get StartedThese Example AtUnit Tests are the quickest way to get started with AtUnit. They demonstrate most permutations of supported containers and mock frameworks, and illustrate the various ways AtUnit makes writing tests easier. [Less]

Desenvolvido com tecnologias voltadas a java, gerencia todos os aspectos da vida escolar do aluno, como faltas, entragas de trabalhos, notas em provas, permitindo inclusão de observações em cada ... [More] uma dessas etapas. Todas essas informações serão armazenados de forma centralizada em um único ponto, permitindo análize a partir de gráficos sobre o desempenho do aluno, assim como poderá receber o 'feedback' dos alunos em relaçao ao professor. Este módulo diz respeito apenas a camada de negócio do sistema [Less]

DescriptionThe target of this project is to build easy, reliable, flexible and universal Java Configuration Tool. This library is very good and also very compact implementation of IoC(Inversion of ... [More] Control) and DI(Dependency Injection) programming concepts. Jar is very small and is suitable even for Java Applets. Works well and for Java Clients and for Java Server Applications. Can manage very small and very large number of configuration parameters. Can inject configuration values into any reachable Java Class and/or Java Object. RequirementsThis is a library of several Java Classes packaged into jar This tool allows setting new values to Java class and instance properties This tool fits to any Java project and is generic It is simple and intuitively understandable It is XML based declarative programming style It is easily integrating with any Java project with minimum efforts and maximum use It can handle hundreds of thousands configuration parameters It supports several levels of Hierarchy. As Package, Class, Instances, Parameters, Arrays and Files Hierarchies Configuration structure could be not matching the code structure Soft code reflection. Meaning use Java reflection capabilities in soft manner avoiding performance and resources management problems Type freedom. Configuration is not dependent on code parameters types. Configuration could be even more complex and more flexible than java code(Type freedom concept is about developing configuration and code separately and then easy integrate) Interpretation is taking over interfacing Tofigurator is built on Elementry Principals Contents tofigurator Featurestofigurator package is made to configure Java Classes and Instances of Java Classes Configuration is defined in XML files Configuration files could import other configuration files. That creates a hierarchy of files. Recursive cross imports problem is resolved by allowing one time import for each file tofigurator synchronizes it's inner configuration storage with Java System Properties. That allows accessing to System Parameters through tofigurator tools. tofigurator is capable of exporting of all configuration parameters into XML files in flat and hierarchical manner. tofigurator is capable to set values to all variables of all Java primitive types with any level of access protection. Meaning even private inner members of object are configurable by tofigurator package tofigurator is capable to set values to String, Date and ParameterizedString members. Other special interpretation types could be easily added tofigurator is self-configurable and for example the syntax of configuration XML files could be changed through configuration without changing the code tofigurator is implemented as regular java class CConfigurator. Some additional functionalities are implemented in static wrapper SConfigurator Configuration and Class structure matching is not mandatory. tofigurator is complaint to Type Freedom programming concept tofigurator doesn't change value of class member if corresponding configuration parameter is not specified. So default values yet could be defined in Java classes Configuration could be silent or not. Depends on configuration parameter. Default for tofigurator is silent behavior. If silent parameter is set to false tofigurator will report every conflict and parameter missing. That could prevent configuration problems and complications while code debugging For more information click on Contents [Less]

org.bamboo.spring.BeanFactory provided to allowed you to create bean and add it to Spring IoC container dynamically, so operations on the bean can be controlled by Spring, e.g. auto proxy AOP etc. ... [More] Code example as following, OrderService orderService = (OrderService) BeanFactory.createBean(OrderService.class); orderService.deleteOrder("AA001"); [Less]

Arid POJOs is a framework for simplifying POJO application development. Automatic Spring Bean GenerationArid POJOs provides a custom Spring/XML namespace that scans a package hierarchy and generate ... [More] bean definitions for the classes or interfaces that it finds. The classes and interfaces can be filtered by an AspectJ type pattern, which supports various criteria including name matching, annotations, and subtypes. The generated beans use autowiring. Here is a simple example. ... ... The generated bean definitions can also instantiate an entirely different class. The original interface/class is passed as a constructor argument. This is used, for example, with the dynamic Generic DAO feature. Dynamic Generic DAOsArid POJOs can also generate DAO implementations from an interface using a Grails GORM/Rails Active Record like mechanism. Here is an example interface: public interface CustomerRepository extends GenericDao { Customer findByCustomerId(String customerId); Customer findUsingSomeStrangeNamedQuery(String firstName, String lastName); }Arid POJOs will generate a proxy, which implements this interface. The findByCustomerId() method is turned into Criteria Query, which searches on the customerId property, and the findUsingSomeStrangeNamedQuery() method ends up calling a named query. This is accomplished using the following bean definitions: ... ... [Less]