StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
10414747
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
0
CommunityOwnedDate
2012-05-02T15:58:27.053
CreationDate
2012-05-02T13:28:27.027
FavoriteCount
0
LastActivityDate
2012-05-02T13:36:25.467
LastEditDate
2012-05-02T13:36:25.467
LastEditorUserId
621514
OwnerUserId
621514
ParentId
10384473
PostTypeId
2
Score
0
ViewCount
0
LastEditorDisplayName
text
Body
I finally think I got it! Sorry for the lack of information in my question. Ryan Stewart wrote "There's no reason your "stringList" and "validationList" can't be managed by a DI container and injected into your StringValidator.", and maybe he had this in mind. If you did, than that was the answer I was looking for, and your answer is correct, so thank you. I found it myself by experimenting in Spring. If I use the classes that contain the lists, than the resulting class cannot recive the lists. They are dynamically created, and I saw no way to bring them to StringValidator. Dynamically means - without the control of the container. The only way I could have injeted them was to inject them directly into StringValidator. But I forgot one thing. Spring is much more flexibile(based on my experience) - I frankly don't know how I could have solved this in Guice(haven't really tried, maybe I'll give it a go). Why not create the list dynamically, and use that list in the container life as a list that can be used to inject the required class? <img src="https://i.stack.imgur.com/q6yMm.jpg" alt="enter image description here"> The point being, when the container initializes the list: <pre><code>package test; import org.springframework.stereotype.Component; import java.util.ArrayList; @Component public class StringList extends ArrayList<String> { } package test; import org.springframework.stereotype.Component; import java.util.ArrayList; @Component public class ValidationList extends ArrayList<String> { } </code></pre> Or if you prefer the xml way(commented): <pre><code><?xml version="1.0" encoding="UTF-8" standalone="no"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.1.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd"> <context:component-scan base-package="test"/>   </beans> </code></pre> That list can be used throught the life of the container, thus the application. <pre><code>package test; import org.springframework.stereotype.Component; import javax.inject.Inject; import java.util.ArrayList; import java.util.List; @Component public class StringService implements Stringable { private List<String> stringList; @Inject public StringService(final ArrayList<String> stringList) { this.stringList = stringList; createList(); } //Simplified private void createList() { stringList.add("FILE1.txt"); stringList.add("FILE1.dat"); stringList.add("FILE1.pdf"); stringList.add("FILE1.rdf"); } @Override public List<String> getStringList() { return stringList; } } package test; import org.springframework.stereotype.Component; import javax.inject.Inject; import java.util.ArrayList; import java.util.List; @Component public class ValidationService implements Validateable { private List<String> validationList; @Inject public ValidationService(final ArrayList<String> validationList) { this.validationList = validationList; createList(); } //Simplified... private void createList() { validationList.add("FILE1.txt"); validationList.add("FILE2.txt"); validationList.add("FILE3.txt"); validationList.add("FILE4.txt"); } @Override public List<String> getValidationList() { return validationList; } } </code></pre> And, I don't have to worry about the services, because the lists are now in the container, living their own lifecycle, thus available every time i request them. <pre><code>package test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import java.util.ArrayList; import java.util.List; @Component public class StringValidator { private List<String> stringList; private List<String> validationList; private final List<String> validatedList = new ArrayList<String>(); @Autowired public StringValidator(final ArrayList<String> stringList, final ArrayList<String> validationList) { this.stringList = stringList; this.validationList = validationList; } public void validate() { for (String currentString : stringList) { for (String currentValidation : validationList) { if (currentString.equalsIgnoreCase(currentValidation)) { validatedList.add(currentString); } } } } public List<String> getValidatedList() { return validatedList; } } </code></pre> The answer actually looks very simple, but it took me some time before I could get here. So, the Main class looks like this, and everything is handeled by the container. <pre><code>package test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import org.springframework.stereotype.Component; import java.util.List; @Component public class Main { @Autowired private StringValidator stringValidator; public void main() { stringValidator.validate(); final List<String> validatedList = stringValidator.getValidatedList(); for (String currentValid : validatedList) { System.out.println(currentValid); } } public static void main(String[] args) { ApplicationContext container = new ClassPathXmlApplicationContext("/META-INF/spring/applicationContext.xml"); container.getBean(Main.class).main(); } } </code></pre> It seems possible. So to recap the answer - you could always have the dynamically created class in the container, and a pretty good decoupleing!
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. PODependency injection, delayed injection praxis
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. USpfh
UserOwnerUserId
1. USpfh
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. PODependency injection, delayed injection praxis
 singulars
 PostTypePostTypeId
 PTQuestion
PostsParentIdCreationDate
1. This table or related slice is empty.
VotesPostIdCreationDate
1. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTAcceptedByOriginator
CommentsPostId
1. This table or related slice is empty.

Querying!

Guidance

A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.