I want to display the data in list using zk by taking data from dataprovider - listbox

I have these files and i want to display the datas in the list.
Person.java
package com.person.info;
public class Person {
private int id;
private String name;
private String address;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public Person(int id, String name, String address) {
super();
this.id = id;
this.name = name;
this.address = address;
}
}
PersonDataProvider.java
package com.person.info;
import java.util.ArrayList;
import java.util.List;
public class PersonDataProvider {
public static List<Person> getPerson() {
List<Person> person=new ArrayList<Person>();
person.add( new Person(1,"Prabin","Thimi"));
person.add( new Person(2,"Rabin","Bhaktapur"));
return person;
}
}
PersonController.java
package com.person.info;
import java.util.List;
import org.zkoss.zk.ui.Component;
import org.zkoss.zk.ui.select.SelectorComposer;
public class PersonController extends SelectorComposer<Component> {
/**
*
*/
private static final long serialVersionUID = 1L;
List<Person> person = PersonDataProvider.getPerson();
public List<Person> getPerson()
{
return person;
}
Person.zul
<?page title="new page title" contentType="text/html;charset=UTF-8"?>
<zk>
<window title="new page title" border="normal" apply="com.person.info.PersonController">
<listbox model="${$composer.person}">
<listhead>
<listheader label="ID" sort="auto" />
<listheader label="Name" sort="auto" />
<listheader label="Address" sort="auto" />
</listhead>
<template name="model">
<listitem>
<listcell label="${each.id}" />
<listcell label="${each.name}" />
<listcell label="${each.address}" />
</listitem>
</template>
</listbox>
</window>
</zk>

Here Zk Listbox you can check a delete and populated example of zk Listbox

Related

Thymeleaf: Empty List doesn't show input fields

I'm trying to create a html "Edit/New" page to edit or add new a publisher. One of the details would be an ArrayList of subPublishers. Although the ArrayList might be empty if the publisher has no subPublishers or if i add new publisher.
My issue is with the input fields. I'm attempting to show the ArrayList as follows...
<form id="publisherForm" th:object="${publisherForm}" th:action="#{/publishers/publishers-edit/}" method="post" class="form-horizontal">
<input type="hidden" th:field="*{id}" />
<div class="row">
<div class="col-sm-6 b-r">
<div class="form-group">
<label class="col-sm-3 control-label">Publisher name: </label>
<div class="col-sm-9">
<input th:field="*{publisherName}" type="text" class="form-control" th:maxlength="45"/>
</div>
</div>
<div class="form-group">
<label class="col-sm-3 control-label">Description: </label>
<div class="col-sm-9">
<input th:field="*{description}" type="text" class="form-control" th:maxlength="200"/>
</div>
</div>
<div class="form-group">
<label class="col-sm-3 control-label">Enabled: </label>
<div class="col-sm-9">
<input th:field="*{status}" value="ENABLED" type="checkbox"/>
</div>
</div>
<div class="form-group">
<label class="col-sm-3 control-label">Website URL: </label>
<div class="col-sm-9">
<input th:field="*{websiteURL}" type="text" class="form-control" th:maxlength="50"/>
</div>
</div>
<div class="form-group">
<label class="col-sm-3 control-label">Subpublishers: </label>
<div class="col-sm-9">
<div class="table-responsive">
<table class="table table-bordered table-striped">
<thead>
<th>
<button class="btn btn-white" type="submit" name="addRow">+</button>
</th>
</thead>
<tbody>
<tr th:each="subPublisher,stat : *{subPublishers}">
<td>
<input type="text" class="form-control" th:field="*{subPublishers[__${stat.index}__].name}" />
</td>
<td>
<button class="btn btn-white" type="submit" name="removeRow" th:value="${stat.index}">-</button>
</td>
</tr>
</tbody>
</table>
</div>
</div>
</div>
</div>
</div>
<div class="row">
<div class="col-sm-6">
<div class="form-group">
<div class="col-sm-9 col-sm-offset-3">
<button class="btn btn-primary" type="submit">Save</button>
<a class="btn btn-white" th:href="#{/publishers}">Cancel</a>
</div>
</div>
</div>
</div>
</form>
Controller
#MenuController(value = "/publisher", item = Item.Publishers)
public class PublisherController {
private PublisherService publisherService;
private PublisherConverter publisherConverter;
private SubPublisherConverter subPublisherConverter;
public PublisherController(PublisherService publisherService, PublisherConverter publisherConverter, SubPublisherConverter subPublisherConverter) {
this.publisherService = publisherService;
this.publisherConverter = publisherConverter;
this.subPublisherConverter = subPublisherConverter;
}
#GetMapping
public String newPublisher( Model model) {
PublisherResource publisher = new PublisherResource();
publisher.setStatus(true);
publisher.setSubPublishers(new ArrayList<SubPublisherResource>());
return showPage(publisher, model);
}
protected String showPage(PublisherResource publisher, Model model) {
model.addAttribute("publisherForm", publisher);
return "publishers/publishers-edit";
}
#PostMapping
public String createPublisher(#ModelAttribute("publisherForm") #Validated PublisherResource resource, BindingResult result, Model model) {
if (result.hasErrors()) {
return showPage(resource, model);
}
return savePublisher(0, resource);
}
#GetMapping("/{publisherId}")
public String editPublisher(#PathVariable int publisherId, Model model) {
Publisher publisher = publisherService.getPublisher(publisherId);
PublisherResource res = publisherConverter.convert(publisher);
res.setSubPublishers(publisherService.getSubPublishers(publisher).stream()
.map(s -> subPublisherConverter.convert(s))
.collect(Collectors.toList())
);
return showPage(res, model);
}
#PostMapping("/{publisherId}")
public String updatePublisher(#PathVariable int publisherId, #ModelAttribute("publisherForm") #Validated PublisherResource resource, BindingResult result, Model model) {
if (result.hasErrors()) {
return showPage(resource, model);
}
return savePublisher(publisherId, resource);
}
protected String savePublisher(int publisherId, PublisherResource resource) {
Publisher publisher = populatePublisher(publisherId, resource);
List<SubPublisher> subPublishers = populateSubPublishers(resource);
if (publisherId == 0) {
publisherService.createPublisher(publisher, subPublishers);
} else {
publisherService.updatePublisher(publisher, subPublishers);
}
return "redirect:/publishers";
}
protected Publisher populatePublisher(int publisherId, PublisherResource resource) {
Publisher publisher = null;
if (publisherId == 0) {
publisher = new Publisher();
publisher.setTimeAdded(new Date());
} else {
publisher = publisherService.getPublisher(publisherId);
}
publisher.setPublisherName(resource.getPublisherName());
publisher.setDescription(resource.getDescription());
publisher.setStatus(resource.isStatus());
publisher.setWebsiteURL(resource.getWebsiteURL());
return publisher;
}
protected List<SubPublisher> populateSubPublishers(PublisherResource resource){
if(resource.getSubPublishers() != null){
return resource.getSubPublishers().stream()
.map(s -> {
SubPublisher subPublisher = new SubPublisher();
subPublisher.setName(s.getName());
return subPublisher;
})
.collect(Collectors.toList());
}
return Collections.emptyList();
}
#PostMapping(params={"addRow"})
public String addRow(final PublisherResource publisher, final BindingResult bindingResult, Model model) {
publisher.getSubPublishers().add(new SubPublisherResource());
return showPage(publisher, model);
}
#PostMapping(params={"removeRow"})
public String removeRow(final PublisherResource publisher, final BindingResult bindingResult,
final HttpServletRequest req, Model model) {
final Integer rowId = Integer.valueOf(req.getParameter("removeRow"));
publisher.getSubPublishers().remove(rowId.intValue());
return showPage(publisher, model);
}
}
PublisherResource
public class PublisherResource {
private int id;
private String publisherName;
private String description;
private boolean status;
private String websiteURL;
private List<SubPublisherResource> subPublishers = new ArrayList<>();
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getPublisherName() {
return publisherName;
}
public void setPublisherName(String publisherName) {
this.publisherName = publisherName;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public boolean isStatus() {
return status;
}
public void setStatus(boolean status) {
this.status = status;
}
public String getWebsiteURL() {
return websiteURL;
}
public void setWebsiteURL(String websiteURL) {
this.websiteURL = websiteURL;
}
public List<SubPublisherResource> getSubPublishers() {
return subPublishers;
}
public void setSubPublishers(List<SubPublisherResource> subPublishers) {
this.subPublishers = subPublishers;
}
}
I use exampel from thymeleaf documentation http://www.thymeleaf.org/doc/tutorials/2.1/thymeleafspring.html#dynamic-fields
The problem is that when the ArrayList is empty, the input fields do not show on the page! Also when edit publisher that have subpublishers, if i remove all of them i lose input fields and I can't add any other subpublishers. Which pretty much makes it impossible to add an subpublishers.
How is this handled with Thymeleaf?
Update Controller
#MenuController(value = "/publisher", item = Item.Publishers)
public class PublisherController {
private PublisherResource publisherResource;
private PublisherService publisherService;
private PublisherConverter publisherConverter;
private SubPublisherConverter subPublisherConverter;
public PublisherController(PublisherResource publisherResource, PublisherService publisherService,
PublisherConverter publisherConverter, SubPublisherConverter subPublisherConverter) {
this.publisherResource = publisherResource;
this.publisherService = publisherService;
this.publisherConverter = publisherConverter;
this.subPublisherConverter = subPublisherConverter;
}
#GetMapping
public String newPublisher( Model model) {
PublisherResource publisher = new PublisherResource();
publisher.setStatus(true);
publisher.setSubPublishers(new ArrayList<SubPublisherResource>());
return showPage(publisher, model);
}
protected String showPage(PublisherResource publisher, Model model) {
model.addAttribute("publisherForm", publisher);
return "publishers/publishers-edit";
}
#PostMapping
public String createPublisher(#ModelAttribute("publisherForm") #Validated PublisherResource resource, BindingResult result, Model model) {
if (result.hasErrors()) {
return showPage(resource, model);
}
return savePublisher(0, resource);
}
#GetMapping
public String editPublisher(Model model) {
Publisher publisher = publisherService.getPublisher(publisherResource.getId());
PublisherResource res = publisherConverter.convert(publisher);
res.setSubPublishers(publisherService.getSubPublishers(publisher).stream()
.map(s -> subPublisherConverter.convert(s))
.collect(Collectors.toList())
);
return showPage(res, model);
}
#PostMapping
public String updatePublisher( #ModelAttribute("publisherForm") #Validated PublisherResource resource, BindingResult result, Model model) {
if (result.hasErrors()) {
return showPage(resource, model);
}
return savePublisher(publisherResource.getId(), resource);
}
protected String savePublisher(int publisherId, PublisherResource resource) {
Publisher publisher = populatePublisher(publisherId, resource);
List<SubPublisher> subPublishers = populateSubPublishers(resource);
if (publisherId == 0) {
publisherService.createPublisher(publisher, subPublishers);
} else {
publisherService.updatePublisher(publisher, subPublishers);
}
return "redirect:/publishers";
}
protected Publisher populatePublisher(int publisherId, PublisherResource resource) {
Publisher publisher = null;
if (publisherId == 0) {
publisher = new Publisher();
publisher.setTimeAdded(new Date());
} else {
publisher = publisherService.getPublisher(publisherId);
}
publisher.setPublisherName(resource.getPublisherName());
publisher.setDescription(resource.getDescription());
publisher.setStatus(resource.isStatus());
publisher.setWebsiteURL(resource.getWebsiteURL());
return publisher;
}
protected List<SubPublisher> populateSubPublishers(PublisherResource resource){
if(resource.getSubPublishers() != null){
return resource.getSubPublishers().stream()
.map(s -> {
SubPublisher subPublisher = new SubPublisher();
subPublisher.setName(s.getName());
return subPublisher;
})
.collect(Collectors.toList());
}
return Collections.emptyList();
}
#PostMapping(params={"addRow"})
public String addRow(final PublisherResource publisher, final BindingResult bindingResult, Model model) {
publisher.getSubPublishers().add(new SubPublisherResource());
return showPage(publisher, model);
}
#PostMapping(params={"removeRow"})
public String removeRow(final PublisherResource publisher, final BindingResult bindingResult,
final HttpServletRequest req, Model model) {
final Integer rowId = Integer.valueOf(req.getParameter("removeRow"));
publisher.getSubPublishers().remove(rowId.intValue());
return showPage(publisher, model);
}
}
Update 2 - all code:
Entities Publisher and SubPublisher:
#Entity
#Table(name = "publisher")
public class Publisher {
#Id
#GeneratedValue(strategy = GenerationType.IDENTITY)
#Column(name = "id")
private int id;
#Column(name = "name")
private String publisherName;
#Column(name = "description")
private String description;
#Column(name = "status")
private boolean status;
#Column(name = "website_url")
private String websiteURL;
#Column(name = "time_added")
private Date timeAdded;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getPublisherName() {
return publisherName;
}
public void setPublisherName(String publisherName) {
this.publisherName = publisherName;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public boolean isStatus() {
return status;
}
public void setStatus(boolean status) {
this.status = status;
}
public String getWebsiteURL() {
return websiteURL;
}
public void setWebsiteURL(String websiteURL) {
this.websiteURL = websiteURL;
}
public Date getTimeAdded() {
return timeAdded;
}
public void setTimeAdded(Date timeAdded) {
this.timeAdded = timeAdded;
}
}
#Entity
#Table(name = "sub_publisher")
public class SubPublisher {
#Id
#GeneratedValue(strategy = GenerationType.IDENTITY)
#Column(name = "id")
private int id;
#OneToOne(fetch = FetchType.LAZY)
#JoinColumn(name = "publisher_id")
private Publisher publisher;
#Column(name = "name")
private String name;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public Publisher getPublisher() {
return publisher;
}
public void setPublisher(Publisher publisher) {
this.publisher = publisher;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Repositories
public interface PublisherRepository extends JpaDataTableRepository<Publisher, Integer> {
public Publisher findById(int id);
}
public interface SubPublisherRepository extends JpaRepository<SubPublisher, Integer> {
List<SubPublisher> findByPublisher(Publisher publisher);
void deleteByPublisher(Publisher publisher);
}
PublisherResource
public class PublisherResource {
private int id;
private String publisherName;
private String description;
private boolean status;
private String websiteURL;
private List<SubPublisherResource> subPublishers = new ArrayList<>();
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getPublisherName() {
return publisherName;
}
public void setPublisherName(String publisherName) {
this.publisherName = publisherName;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public boolean isStatus() {
return status;
}
public void setStatus(boolean status) {
this.status = status;
}
public String getWebsiteURL() {
return websiteURL;
}
public void setWebsiteURL(String websiteURL) {
this.websiteURL = websiteURL;
}
public List<SubPublisherResource> getSubPublishers() {
return subPublishers;
}
public void setSubPublishers(List<SubPublisherResource> subPublishers) {
this.subPublishers = subPublishers;
}
}
SubPublisherResource
public class SubPublisherResource {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
PublisherController
#Controller
#RequestMapping("/publisher")
public class PublisherController {
private PublisherService publisherService;
private PublisherConverter publisherConverter;
private SubPublisherConverter subPublisherConverter;
#Autowired
public PublisherController(PublisherService publisherService, PublisherConverter publisherConverter, SubPublisherConverter subPublisherConverter) {
this.publisherService = publisherService;
this.publisherConverter = publisherConverter;
this.subPublisherConverter = subPublisherConverter;
}
#GetMapping
public String newPublisher(Model model) {
PublisherResource publisher = new PublisherResource();
publisher.setStatus(true);
return showPage(publisher, model);
}
protected String showPage(PublisherResource publisher, Model model) {
model.addAttribute("publisherForm", publisher);
return "/publishers/publishers-edit";
}
#PostMapping
public String createPublisher(#ModelAttribute("publisherForm") #Validated PublisherResource resource, BindingResult result, Model model) {
if(result.hasErrors()) {
return showPage(resource, model);
}
return savePublisher(resource);
}
#GetMapping("/{id}")
public String editPublisher(#PathVariable("id") Integer id, Model model) {
Publisher publisher = publisherService.getPublisher(id);
PublisherResource res = publisherConverter.convert(publisher);
res.setSubPublishers(publisherService.getSubPublishers(publisher).stream().map(s->subPublisherConverter.convert(s)).collect(Collectors.toList()));
return showPage(res, model);
}
protected String savePublisher(PublisherResource resource) {
Publisher publisher = populatePublisher(resource);
List<SubPublisher> subPublishers = populateSubPublishers(resource);
if(resource.getId() == 0) {
publisherService.createPublisher(publisher, subPublishers);
} else {
publisherService.updatePublisher(publisher, subPublishers);
}
return "redirect:/publishers";
}
protected Publisher populatePublisher(PublisherResource resource) {
Publisher publisher;
if(resource.getId() == 0) {
publisher = new Publisher();
publisher.setTimeAdded(new Date());
} else {
publisher = publisherService.getPublisher(resource.getId());
}
publisher.setPublisherName(resource.getPublisherName());
publisher.setDescription(resource.getDescription());
publisher.setStatus(resource.isStatus());
publisher.setWebsiteURL(resource.getWebsiteURL());
return publisher;
}
protected List<SubPublisher> populateSubPublishers(PublisherResource resource) {
if(resource.getSubPublishers() != null) {
return resource.getSubPublishers().stream().map(s->{
SubPublisher subPublisher = new SubPublisher();
subPublisher.setName(s.getName());
return subPublisher;
}).collect(Collectors.toList());
}
return Collections.emptyList();
}
#PostMapping(params = { "addRow" })
public String addRow(final PublisherResource publisher, Model model) {
publisher.getSubPublishers().add(new SubPublisher());
return showPage(publisher, model);
}
#PostMapping(params = { "removeRow" })
public String removeRow(final PublisherResource publisher, final HttpServletRequest req, Model model) {
final Integer rowId = Integer.valueOf(req.getParameter("removeRow"));
publisher.getSubPublishers().remove(rowId.intValue());
return showPage(publisher, model);
}
}
PublishersController
#MenuController(value = "/publishers", item = Item.Publishers)
public class PublishersController {
private PublisherService publisherService;
private PublisherConverter publisherConverter;
public PublishersController(PublisherService publisherService, PublisherConverter publisherConverter) {
this.publisherService = publisherService;
this.publisherConverter = publisherConverter;
}
#GetMapping
public String showPage() {
return "publishers/publishers";
}
#PostMapping("/data")
public #ResponseBody DataTableResponse<PublisherResource> getPublishers(#RequestBody DataTableRequest request) {
return publisherConverter.convertResponse(publisherService.getPublishers(request));
}
#DeleteMapping("/{publisherIds}")
#ResponseStatus(HttpStatus.NO_CONTENT)
public void deletePublishers(#PathVariable Integer[] publisherIds) {
for (Integer publisherId: publisherIds) {
publisherService.deletePublisher(publisherId);
}
}
#PutMapping("/{publisherIds}/disable")
#ResponseStatus(HttpStatus.ACCEPTED)
public void disablePublishers(#PathVariable Integer[] publisherIds) {
changeStatus(publisherIds);
}
#PutMapping("/{publisherIds}/enable")
#ResponseStatus(HttpStatus.ACCEPTED)
public void enablePublishers(#PathVariable Integer[] publisherIds) {
changeStatus(publisherIds);
}
protected void changeStatus(Integer[] publisherIds) {
for (Integer publisherId: publisherIds) {
publisherService.updateStatus(publisherId);
}
}
}
PublisherConverter
#Component
public class PublisherConverter implements ResourceConverter<Publisher, PublisherResource> {
public PublisherResource convert(Publisher publisher) {
PublisherResource resource = new PublisherResource();
resource.setId(publisher.getId());
resource.setPublisherName(publisher.getPublisherName());
resource.setDescription(publisher.getDescription());
resource.setStatus(publisher.isStatus());
resource.setWebsiteURL(publisher.getWebsiteURL());
return resource;
}
}
PublisherService
#Service
public class PublisherService {
private PublisherRepository publisherRepository;
private SubPublisherRepository subPublisherRepository;
public PublisherService(PublisherRepository publisherRepository, SubPublisherRepository subPublisherRepository) {
this.publisherRepository = publisherRepository;
this.subPublisherRepository = subPublisherRepository;
}
public DataTableResponse<Publisher> getPublishers(DataTableRequest request) {
return publisherRepository.findAll(request);
}
#Transactional
public Publisher getPublisher(int publisherId) {
Publisher publisher = publisherRepository.findById(publisherId);
if(publisher != null){
List<SubPublisher> subPublishers = subPublisherRepository.findByPublisher(publisher);
//populateSubPublishers(subPublishers);
subPublishers.stream().forEach(s -> {
if(s.getId() == 0){
s.setPublisher(publisher);
subPublisherRepository.save(s);
}
});
}
if(publisher == null) {
throw new NotFoundException("Publisher " + publisherId + " not found.");
}
return publisher;
}
private void populateSubPublishers(List<SubPublisher> subPublishers) {
for(SubPublisher subPublisher : subPublishers){
subPublishers.add(subPublisher);
System.out.println(subPublisher.getName());
}
}
#Transactional
public Publisher createPublisher(Publisher publisher, List<SubPublisher> subPublishers) {
publisher = publisherRepository.save(publisher);
createSubPublisher(publisher, subPublishers);
return publisher;
}
private void createSubPublisher(Publisher publisher, List<SubPublisher> subPublishers) {
populateSubPublishers(subPublishers);
for(SubPublisher subPublisher : subPublishers){
subPublisher.setPublisher(publisher);
subPublisher.setName(subPublisher.getName());
}
}
#Transactional
public Publisher updatePublisher(Publisher publisher, List<SubPublisher> subPublishers) {
publisher = publisherRepository.save(publisher);
createSubPublishers(publisher, subPublishers);
return publisher;
}
private void createSubPublishers(Publisher publisher, List<SubPublisher> subPublishers) {
subPublisherRepository.deleteByPublisher(publisher);
for (SubPublisher sp : subPublishers) {
sp.setPublisher(publisher);
sp = subPublisherRepository.save(sp);
}
}
#Transactional
public void updateStatus(int publisherId) {
Publisher publisher = publisherRepository.findOne(publisherId);
if(publisher != null && publisher.isStatus() != false){
publisher.setStatus(false);
publisherRepository.save(publisher);
}
else if(publisher != null && publisher.isStatus() != true ){
publisher.setStatus(true);
publisherRepository.save(publisher);
}
}
#Transactional
public void deletePublisher(int publisherId) {
Publisher publisher = publisherRepository.findOne(publisherId);
if (publisher != null) {
publisherRepository.delete(publisher);
}
}
public List<SubPublisher> getSubPublishers(Publisher publisher){
return subPublisherRepository.findByPublisher(publisher);
}
}
SubPublisherConverter
#Component
public class SubPublisherConverter implements ResourceConverter<SubPublisher, SubPublisherResource> {
#Override
public SubPublisherResource convert(SubPublisher subPublisher) {
SubPublisherResource resource = new SubPublisherResource();
resource.setName(subPublisher.getName());
return resource;
}
}
Error
java.util.ConcurrentModificationException: null
at java.util.ArrayList$Itr.checkForComodification(Unknown Source)
at java.util.ArrayList$Itr.next(Unknown Source)
at publishers.PublisherService.populateSubPublishers(PublisherService.java:58)
at publishers.PublisherService.createSubPublisher(PublisherService.java:74)
at publishers.PublisherService.createPublisher(PublisherService.java:68)
So here is the example. Ofc you need to replace the mapping for the controller (/test/test) to /publishers/publishers-edit. Controller:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import javax.servlet.http.HttpServletRequest;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
#Controller
#RequestMapping("/test/test")
public class PublisherController {
private PublisherService publisherService;
private PublisherConverter publisherConverter;
private SubPublisherConverter subPublisherConverter;
#Autowired
public PublisherController(PublisherService publisherService, PublisherConverter publisherConverter, SubPublisherConverter subPublisherConverter) {
this.publisherService = publisherService;
this.publisherConverter = publisherConverter;
this.subPublisherConverter = subPublisherConverter;
}
#GetMapping
public String newPublisher(Model model) {
PublisherResource publisher = new PublisherResource();
publisher.setStatus(true);
return showPage(publisher, model);
}
protected String showPage(PublisherResource publisher, Model model) {
model.addAttribute("publisherForm", publisher);
return "test/test";
}
#PostMapping
public String createPublisher(#ModelAttribute("publisherForm") #Validated PublisherResource resource, BindingResult result, Model model) {
if(result.hasErrors()) {
return showPage(resource, model);
}
return savePublisher(resource);
}
#GetMapping("/{id}")
public String editPublisher(#PathVariable("id") Integer id, Model model) {
Publisher publisher = publisherService.getPublisher(id);
PublisherResource res = publisherConverter.convert(publisher);
res.setSubPublishers(publisherService.getSubPublishers(publisher).stream().map(s->subPublisherConverter.convert(s)).collect(Collectors.toList()));
return showPage(res, model);
}
protected String savePublisher(PublisherResource resource) {
Publisher publisher = populatePublisher(resource);
List<SubPublisher> subPublishers = populateSubPublishers(resource);
if(resource.getId() == 0) {
publisherService.createPublisher(publisher, subPublishers);
} else {
publisherService.updatePublisher(publisher, subPublishers);
}
return "redirect:/publishers";
}
protected Publisher populatePublisher(PublisherResource resource) {
Publisher publisher;
if(resource.getId() == 0) {
publisher = new Publisher();
publisher.setTimeAdded(new Date());
} else {
publisher = publisherService.getPublisher(resource.getId());
}
publisher.setPublisherName(resource.getPublisherName());
publisher.setDescription(resource.getDescription());
publisher.setStatus(resource.isStatus());
publisher.setWebsiteURL(resource.getWebsiteURL());
return publisher;
}
protected List<SubPublisher> populateSubPublishers(PublisherResource resource) {
if(resource.getSubPublishers() != null) {
return resource.getSubPublishers().stream().map(s->{
SubPublisher subPublisher = new SubPublisher();
subPublisher.setName(s.getName());
return subPublisher;
}).collect(Collectors.toList());
}
return Collections.emptyList();
}
#PostMapping(params = { "addRow" })
public String addRow(#ModelAttribute("publisherForm") final PublisherResource publisher, Model model) {
publisher.getSubPublishers().add(new SubPublisher());
return showPage(publisher, model);
}
#PostMapping(params = { "removeRow" })
public String removeRow(#ModelAttribute("publisherForm") final PublisherResource publisher, final HttpServletRequest req, Model model) {
final Integer rowId = Integer.valueOf(req.getParameter("removeRow"));
publisher.getSubPublishers().remove(rowId.intValue());
return showPage(publisher, model);
}
}
Update
I cleaned up your PublisherService and splitted it into PublisherService and SubPublisherService. Those Services are prob. optional but i prefer to have another layer between the repository and my programm most of the time.
I also cleaned up the PublisherController. savePublisher changed a lot. It is documented tho.
The Publisher now also has a List containing all SubPublishers for the Publisher. Prev. you were fetching this via code. However JPA can do this for you.
PublisherController:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
#Controller
#RequestMapping("/test/test")
public class PublisherController {
private PublisherService publisherService;
private SubPublisherService subPublisherService;
#Autowired
public PublisherController(PublisherService publisherService, SubPublisherService subPublisherService) {
this.publisherService = publisherService;
this.subPublisherService = subPublisherService;
}
private ModelAndView showPage(PublisherResource publisher) {
final ModelAndView modelAndView = new ModelAndView("test/test");
modelAndView.addObject("publisherForm", publisher);
return modelAndView;
}
#GetMapping
public ModelAndView createPublisher() {
PublisherResource publisher = new PublisherResource();
publisher.setStatus(true);
return showPage(publisher);
}
#GetMapping("/{id}")
public ModelAndView editPublisher(#PathVariable("id") Integer id) {
Publisher publisher = publisherService.getPublisher(id);
return showPage(PublisherConverter.convert(publisher));
}
#PostMapping
public ModelAndView savePublisher(#ModelAttribute("publisherForm") #Validated PublisherResource resource, BindingResult result) {
if(result.hasErrors()) {
return showPage(resource);
}
return savePublisher(resource);
}
private ModelAndView savePublisher(PublisherResource resource) {
// create the publisher
Publisher publisher;
if(resource.getId() == 0) {
publisher = new Publisher();
publisher.setTimeAdded(new Date());
publisher = publisherService.save(publisher);
} else {
publisher = publisherService.getPublisher(resource.getId());
}
/* -- this will update the SubPublishers -- */
final List<SubPublisher> toDelete = publisher.getSubPublishers();
final List<SubPublisher> toSave = new ArrayList<>();
final Publisher forLambda = publisher;
// first we will iterate over all the SubPublishers that where specified by the user (in the form)
resource.getSubPublishers().forEach(name->{
// we will then try to find any existing SubPublisher for the given name and publisher (to avoid duplicated database entries)
final SubPublisher subPublisher = subPublisherService.getOrCreateSubPublisher(forLambda, name);
// we will also save the SubPublisher reference for later
toSave.add(subPublisher);
// and then we will remove the SubPublisher that we just found from the List of SubPublishers from the original Publisher (that was stored in the db)
toDelete.removeIf(s->subPublisher.getId() == s.getId());
});
// effectively it will leave us with a list (toDelete) that will include all SubPublishers that have to be deleted
for(SubPublisher subPublisher : toDelete) {
// and this is what we will to here
subPublisherService.delete(subPublisher);
}
// after we cleaned up all unused references
publisher.getSubPublishers().clear();
// update the subPublisher list to contain all SubPublishers that where specified by the user input (the parsed ones)
publisher.getSubPublishers().addAll(toSave);
/* -- end -- */
// update all remaining fields
publisher.setPublisherName(resource.getPublisherName());
publisher.setDescription(resource.getDescription());
publisher.setStatus(resource.isStatus());
publisher.setWebsiteURL(resource.getWebsiteURL());
publisherService.save(publisher);
return new ModelAndView("redirect:/test/list");
}
#PostMapping(params = { "addRow" })
public ModelAndView addRow(#ModelAttribute("publisherForm") final PublisherResource publisher) {
publisher.getSubPublishers().add("");
return showPage(publisher);
}
#PostMapping(params = { "removeRow" })
public ModelAndView removeRow(#ModelAttribute("publisherForm") final PublisherResource publisher, final HttpServletRequest req) {
final Integer rowId = Integer.valueOf(req.getParameter("removeRow"));
publisher.getSubPublishers().remove(rowId.intValue());
return showPage(publisher);
}
}
Publisher:
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
#Entity
#Table
public class Publisher {
private int id;
private String publisherName;
private String description;
private boolean status;
private String websiteURL;
private Date timeAdded;
private List<SubPublisher> subPublishers = new ArrayList<>();
#Id
#GeneratedValue(strategy = GenerationType.IDENTITY)
#Column
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
#Column
public String getPublisherName() {
return publisherName;
}
public void setPublisherName(String publisherName) {
this.publisherName = publisherName;
}
#Column
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
#Column
public boolean isStatus() {
return status;
}
public void setStatus(boolean status) {
this.status = status;
}
#Column
public String getWebsiteURL() {
return websiteURL;
}
public void setWebsiteURL(String websiteURL) {
this.websiteURL = websiteURL;
}
#Column
public Date getTimeAdded() {
return timeAdded;
}
public void setTimeAdded(Date timeAdded) {
this.timeAdded = timeAdded;
}
#OneToMany(mappedBy = "publisher")
public List<SubPublisher> getSubPublishers() {
return subPublishers;
}
public void setSubPublishers(List<SubPublisher> subPublishers) {
this.subPublishers = subPublishers;
}
#Override
public String toString() {
return "Publisher{" + "id=" + id + ", publisherName='" + publisherName + '\'' + ", description='" + description + '\'' + ", status=" + status + ", websiteURL='" + websiteURL + '\'' + ", timeAdded=" + timeAdded + ", subPublishers=" + subPublishers + '}';
}
}
PublisherResource:
import java.util.ArrayList;
import java.util.List;
public class PublisherResource {
private int id;
private String publisherName;
private String description;
private boolean status;
private String websiteURL;
private List<String> subPublishers = new ArrayList<>();
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getPublisherName() {
return publisherName;
}
public void setPublisherName(String publisherName) {
this.publisherName = publisherName;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public boolean isStatus() {
return status;
}
public void setStatus(boolean status) {
this.status = status;
}
public String getWebsiteURL() {
return websiteURL;
}
public void setWebsiteURL(String websiteURL) {
this.websiteURL = websiteURL;
}
public List<String> getSubPublishers() {
return subPublishers;
}
public void setSubPublishers(List<String> subPublishers) {
this.subPublishers = subPublishers;
}
}
PublisherService:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
#Service
public class PublisherService {
private PublisherRepository publisherRepository;
#Autowired
public void setPublisherRepository(PublisherRepository publisherRepository) {
this.publisherRepository = publisherRepository;
}
public Publisher save(Publisher toSave) {
return publisherRepository.save(toSave);
}
public void delete(Publisher toDelete) {
publisherRepository.delete(toDelete);
}
public Publisher getPublisher(Integer id) {
return publisherRepository.findOne(id);
}
public Iterable<Publisher> getAll() {
return publisherRepository.findAll();
}
}
PublisherRepository:
import org.springframework.data.repository.CrudRepository;
public interface PublisherRepository extends CrudRepository<Publisher, Integer> {}
PublisherConverter:
import java.util.stream.Collectors;
public class PublisherConverter {
public static PublisherResource convert(Publisher publisher) {
PublisherResource resource = new PublisherResource();
resource.setId(publisher.getId());
resource.setPublisherName(publisher.getPublisherName());
resource.setDescription(publisher.getDescription());
resource.setStatus(publisher.isStatus());
resource.setWebsiteURL(publisher.getWebsiteURL());
resource.getSubPublishers().addAll(publisher.getSubPublishers().stream().map(SubPublisher::getName).collect(Collectors.toList()));
return resource;
}
}
SubPublisher:
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;
#Entity
#Table
public class SubPublisher {
private int id;
private Publisher publisher;
private String name;
#Id
#GeneratedValue(strategy = GenerationType.IDENTITY)
#Column
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
#OneToOne(fetch = FetchType.LAZY)
#JoinColumn(name = "publisherId")
public Publisher getPublisher() {
return publisher;
}
public void setPublisher(Publisher publisher) {
this.publisher = publisher;
}
#Column
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
SubPublisherRepository:
import org.springframework.data.repository.CrudRepository;
public interface SubPublisherRepository extends CrudRepository<SubPublisher, Integer> {
SubPublisher findByPublisherAndAndName(Publisher publisher, String name);
}
SubPublisherService:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
#Service
public class SubPublisherService {
private SubPublisherRepository subPublisherRepository;
#Autowired
public void setSubPublisherRepository(SubPublisherRepository subPublisherRepository) {
this.subPublisherRepository = subPublisherRepository;
}
public SubPublisher save(SubPublisher toSave) {
return subPublisherRepository.save(toSave);
}
public void delete(SubPublisher toDelete) {
subPublisherRepository.delete(toDelete);
}
/**
* This method will either find any existing SubPublisher by the Name and the Publisher or create one if none existed.
*/
public SubPublisher getOrCreateSubPublisher(Publisher publisher, String name) {
SubPublisher subPublisher = subPublisherRepository.findByPublisherAndAndName(publisher, name);
if(subPublisher == null) {
subPublisher = new SubPublisher();
subPublisher.setPublisher(publisher);
subPublisher.setName(name);
subPublisher = save(subPublisher);
}
return subPublisher;
}
public Iterable<SubPublisher> getAll() {
return subPublisherRepository.findAll();
}
}
In the html i changed <input type="text" class="form-control" th:field="*{subPublishers[__${stat.index}__].name}" /> to <input type="text" class="form-control" th:field="*{subPublishers[__${stat.index}__].}" />

Swagger springfox hide model property on POST

Would like to know how to hide a model property in Swagger on POST. I have tried both Swagger-springmvc (0.9.3) and Springfox (supports swagger spec 2.0) to no avail.
Problem being I would like to see this in the GET requests through Swagger. But not POST requests, since id is auto-assigned, I would like to hide it just for the POST request.
public class RestModel {
private int id;
#JsonProperty
private String name;
#JsonProperty
public int getId() {
return 0;
}
#JsonIgnore
public void setId(int customerId) {
this.customerId = customerId;
}
public int getName() {
return "abc";
}
public void setName(String name) {
this.name = name;
}
}
So on GET, I should see:
{
"id": 0,
"name" : "abc"
}
And on POST, I should see just:
{
"name"
}
Tried adding: #ApiModelProperty(readonly=true). But that didn't help.
I have solved this with simply extending the Object that I want to hide a property of when using as request parameter.
Example:
I have the object Person.java:
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonView;
import org.joda.time.DateTime;
import org.joda.time.Years;
import java.util.Date;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import io.swagger.annotations.ApiModelProperty;
/**
* Simple Person pojo
*/
#Entity
public class Person {
#GeneratedValue(strategy = GenerationType.AUTO)
#Id
private Long dbId;
private String name;
private Long id;
#JsonFormat(pattern="yyyy-MM-dd")
private Date birthDate;
private String gender;
public Person() {
}
public Person(long dbId) {
this.dbId = dbId;
}
public Person(Long id, String name, Date birthDate, String gender) {
this.id = id;
this.name = name;
this.birthDate = birthDate;
this.gender = gender;
}
public Long getDbId() {
return dbId;
}
public String getName() {
return name;
}
public Date getBirthDate() {
return birthDate;
}
public String getGender() {
return gender;
}
public Integer getAge() {
return Years.yearsBetween(new DateTime(birthDate), new DateTime()).getYears();
}
public void setDbId(Long dbId) {
this.dbId = dbId;
}
public void setName(String name) {
this.name = name;
}
public void setBirthDate(Date birthDate) {
this.birthDate = birthDate;
}
public void setGender(String gender) {
this.gender = gender;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
}
I have simply created another class: PersonRequest.java:
import com.fasterxml.jackson.annotation.JsonIgnore;
public class PersonRequest extends Person {
#Override
#JsonIgnore
public void setDbId(Long dbId) {
super.setDbId(dbId);
}
}
RequestMapping looks simply like:
#RequestMapping(value = "/KVFirstCare/application", method = RequestMethod.POST)
public ApplicationResult application(#RequestBody List<PersonRequest> persons,
HttpServletResponse response) {
}
Works like charm :)
Unfortunately having different request and response models is not supported currently in springfox. The current thought is that we might support this feature using #JsonView in the future.

How to create joinable entities with Ebean on play framework

How to create enteties in Ebean that reference automaticly with other tabels?
For example in this case:
A user has many photo series.
A photo serie has many photos.
A photo has an extension.
An extension has no references.
Code:
#Entity
public class User extends Model {
#Id
public int id;
#OneToMany
public List<PhotoSerie> photoSeries;
//XXXX
}
#Entity
public class PhotoSerie extends Model {
#Id
public int id;
#OneToMany
public List<Photo> photo;
//XXXX
}
#Entity
public class Photo extends Model {
#Id
public int id;
#OneToOne
PhotoExtension photoExtension;
//XXXX
}
#Entity
public class PhotoExtension extends Model {
#Id
public int id;
public String extension;
//XXXX
}
The following error will be generated:
[error] c.a.e.s.d.BeanDescriptorManager - Error in deployment
javax.persistence.PersistenceException: Error on models.PhotoSerie.photo. #OneTo
Many MUST have Cascade.PERSIST or Cascade.ALL bejavax.persistence.PersistenceExc
eption: Error on models.PhotoSerie.photo. #OneToMany MUST have Cascade.PERSIST o
r Cascade.ALL because this is a unidirectional relationship. That is, there is n
o property of type class models.PhotoSerie on class models.Photocause this is a
unidirectional relationship. That is, there is no property of type class models.
PhotoSerie on class models.Photo
How can I create entities that join in a correct way with other tables?
You need the mappedBy on your OneToMany annotations, and CascadeType.ALL on the owner of the relationship. EBean is a little different that regular ORM, and in the play docs, they mention to use setter/getter instead of field reference. Also you need some finders to do lookups. So using setter/getter approach, with play 2.1.2 (at least what I tested with) this works:
User:
package models.test;
import play.db.ebean.Model;
import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;
#Entity
public class User extends Model {
#Id
public int id;
public String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
#OneToMany(cascade = CascadeType.ALL, mappedBy = "user")
public List<PhotoSeries> photoSeries;
public static Finder<String, User> find = new Finder<String, User>(
String.class, User.class);
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public List<PhotoSeries> getPhotoSeries() {
return photoSeries;
}
public void setPhotoSeries(List<PhotoSeries> photoSeries) {
this.photoSeries = photoSeries;
}
}
PhotoSeries:
package models.test;
import play.db.ebean.Model;
import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;
#Entity
public class PhotoSeries extends Model {
#Id
public int id;
#OneToMany(cascade = CascadeType.ALL, mappedBy = "photoSeries")
public List<Photo> photoList;
#ManyToOne
public User user;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public List<Photo> getPhotoList() {
return photoList;
}
public void setPhotoList(List<Photo> photoList) {
this.photoList = photoList;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
}
PhotoExtension:
package models.test;
import play.db.ebean.Model;
import javax.persistence.Entity;
import javax.persistence.Id;
#Entity
public class PhotoExtension extends Model {
#Id
public int id;
public String extension;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getExtension() {
return extension;
}
public void setExtension(String extension) {
this.extension = extension;
}
}
Photo:
package models.test;
import play.db.ebean.Model;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.OneToOne;
#Entity
public class Photo extends Model {
#Id
public int id;
#OneToOne
PhotoExtension photoExtension;
#ManyToOne
PhotoSeries photoSeries;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public PhotoExtension getPhotoExtension() {
return photoExtension;
}
public void setPhotoExtension(PhotoExtension photoExtension) {
this.photoExtension = photoExtension;
}
public PhotoSeries getPhotoSeries() {
return photoSeries;
}
public void setPhotoSeries(PhotoSeries photoSeries) {
this.photoSeries = photoSeries;
}
}
#Test
public void testPhotoSeries() {
User user = new User();
user.setName("Bob");
List<PhotoSeries> photoSeriesList = new ArrayList<PhotoSeries>();
PhotoSeries photoSeries = new PhotoSeries();
photoSeries.setUser(user);
photoSeriesList.add(photoSeries);
user.setPhotoSeries(photoSeriesList);
user.save();
user = User.find.where().eq("name", "Bob").findUnique();
log.info("user has " + user.getPhotoSeries().size() + " photo series");
List<Photo> photoList = new ArrayList<Photo>();
Photo photo = new Photo();
photoList.add(photo);
photoSeries = user.getPhotoSeries().get(0);
photoSeries.setPhotoList(photoList);
user.update();
user = User.find.where().eq("name", "Bob").findUnique();
photoSeries = user.getPhotoSeries().get(0);
photo = photoSeries.getPhotoList().get(0);
log.info("photo " + photo);
}

set method of long variable (setMobile() ) gives error during runtime in action class of struts 2 framework

package com.kumar.student;
import java.util.List;
import com.opensymphony.xwork2.ActionSupport;
public class StudentAction extends ActionSupport {
private static final long serialVersionUID = 1L;
private String name;
private String rollNumber;
private String department;
private String year;
private String dob;
private String email;
private long mobile;
private List<String> gender;
#Override
public String execute() {
return "success";
}
// all setter & getter method for remaining variable
public long getMobile() {
return mobile;
}
public void setMobile(long mobile) {
this.mobile = mobile;
}
public List<String> getGender() {
return gender;
}
public void setGender(List<String> gender) {
this.gender = gender;
}
}
In the above code setMobile(Long mobile) method gives the below exception:
java.lang.NoSuchMethodException: com.kumar.student.StudentAction.setMobile([Ljava.lang.String;)

ManagedProperty not working

I have problem with JSF 2 property binding and honestly I hit a wall here..
What I want to accomplish is this: a request-scoped bean (loginBean) process login action and stores username in the session-scoped bean (userBean). I want to inject userBean into loginBean via #ManagedProperty, but when loginBean.doLoginAction is called, userBean is set to null.
Here is the code:
UserBean class
import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;
#ManagedBean
#SessionScoped
public class UserBean {
private String username;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public boolean isLogged() {
if (username != null)
return true;
return false;
}
}
loginBean class:
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ManagedProperty;
import javax.faces.bean.RequestScoped;
#ManagedBean
#RequestScoped
public class LoginBean {
#ManagedProperty(value = "userBean")
private UserBean userBean;
private String name;
private String password;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public UserBean getUserBean() {
return userBean;
}
public void setUserBean(UserBean userBean) {
this.userBean = userBean;
}
public String doLoginAction() {
if (name.equals("kamil") && password.equals("kamil")) {
userBean.setUsername(name);
}
return null;
}
public String doLogoutAction() {
return null;
}
}
Any ideas what I'm doing wrong here?
You need to specify an EL expression #{}, not a plain string:
#ManagedProperty(value = "#{userBean}")
private UserBean userBean;
or, shorter, since the value attirbute is the default already:
#ManagedProperty("#{userBean}")
private UserBean userBean;
See also:
Communication in JSF2 - Injecting managed beans in each other

Resources