OCJP Latest Dumps

Hi All,

Many people on internet are looking for latest and valid Java SE 1.6 dumps.

On this post, I am sharing valid and latest dumps.

Click Here to download.

Please provide feedback after taking exams about the dumps.

Cheers !!

Question - 2

Give the code. What is the result?

class Hotel {
    public int bookings;
    public void book() {
        bookings++;
    }
}

public class SuperHotel extends Hotel {
    public void book() {
        bookings--;
    }
    
    public void book(int size) {
        book();
        super.book();
        bookings += size;
    }
    
    public static void main(String args[]) {
        SuperHotel hotel = new SuperHotel();
        hotel.book(2);
        System.out.print(hotel.bookings);
    }
}

A) Compilation fails.

B) An exception is thrown at runtime.

C) 0

D) 1

E) 2(Correct Answer)

F) -1

Question - 1

Que:  Given a class Repetition:
1. package utils;
2.
3. public class Repetition {
4. public static String twice(String s) { return s + s; }
5. }
and given another class Demo:
1. // insert code here
2.
3. public class Demo {
4. public static void main(String[] args) {
5. System.out.println(twice("pizza"));
6. }
7. }

Which code should be inserted at line 1 of Demo.java to compile and run Demo to print "pizzapizza"?
A. import utils.*;
B. static import utils.*;
C. import utils.Repetition.*;
D. static import utils.Repetition.*;
E. import utils.Repetition.twice();
F. import static utils.Repetition.twice;
G. static import utils.Repetition.twice;
Answer: F

MongoDB Get names of all keys in collection

mr = db.runCommand({ 

 "mapreduce" : "things", 

 "map" : function() {

   for (var key in this) { 

         emit(key, null); } },

 "reduce" : function(key, stuff) { 

  return null; }, "out": "things" + "_keys" })

Then run distinct on the resulting collection so as to find all the keys:

db[mr.result].distinct("_id") ["foo", "bar", "baz", "_id", ...]

Fetch Image Using Ajax

Introduction

One of the unsung heros in the HTML5 universe is XMLHttpRequest. Strictly speaking XHR2 isn't HTML5. However, it's part of the incremental improvements browser vendors are making to the core platform. I'm including XHR2 in our new bag of goodies because it plays such an integral part in today's complex web apps.

Turns out our old friend got a huge makeover but many folks are unaware of its new features. XMLHttpRequest Level 2 introduces a slew of new capabilities which put an end to crazy hacks in our web apps; things like cross-origin requests, uploading progress events, and support for uploading/downloading binary data. These allow AJAX to work in concert with many of the bleeding edge HTML5 APIs such as File System API, Web Audio API, and WebGL.

Fetching data

Fetching a file as a binary blob has been painful with XHR. Technically, it wasn't even possible. One trick that has been well documented involves overriding the mime type with a user-defined charset as seen below.

$('#linkImg').click(function(e){
                            e.preventDefault();
                            alert("hi");
                            var xhr = new XMLHttpRequest();
                            xhr.open('GET', '/users/exportA', true);
                            xhr.responseType = 'blob';

                            xhr.onload = function(e) {
                            if (this.status == 200) {
                            var blob = this.response;

                            var img = document.createElement('img');
                            img.onload = function(e) {
                            window.URL.revokeObjectURL(img.src); // Clean up after yourself.
                            };
                            img.src = window.URL.createObjectURL(blob);
                            document.body.appendChild(img);

                            }
                            };

                            xhr.send();
                            });

My Controller Code:

 @RequestMapping(value = "/users/exportA")
    @ResponseBody
    public void exportA(HttpServletResponse response)
            throws FileNotFoundException, IOException {

        response.setHeader("Content-Disposition", "inline;filename=Desert.jpg");

        OutputStream out = response.getOutputStream();
        response.setContentType("blob");
        FileCopyUtils.copy(new BufferedInputStream(new FileInputStream(
                "C:\\Users\\Public\\Pictures\\Sample Pictures\\Desert.jpg")), out);

        out.flush();
        out.close();
    }

Require: jquery.min.js (Latest Version)

Export MongoDB "Database" in JAVA

public class TempMongoExportDB {

public void mongoExport()
throws IOException {

String command = "mongodump -db tree -o c:\\backup";
Process p = Runtime.getRuntime().exec(command);
BufferedReader stdInput = new BufferedReader(new InputStreamReader(
p.getInputStream()));

BufferedReader stdError = new BufferedReader(new InputStreamReader(
p.getErrorStream()));

// read the output from the command
String s = "";

while ((s = stdInput.readLine()) != null) {
System.out.println(s);
}

while ((s = stdError.readLine()) != null) {
System.out.println("Std ERROR : " + s);
}

}

public static void main(String[] args) throws IOException {

TempMongoExportDB tempMongoExportDB = new TempMongoExportDB();
tempMongoExportDB.mongoExport();

}

}

Third example: RequestEntityMethodArgumentResolver

 For CRUD operations, a PUT request to a URL is common and usually overwrites the entire object. In our case however, this is not possible: some object properties are read-only, and others can only be written if the object has a certain status. So what we need is a _partial_ update.
And although it is usually possible to omit fields from the request body, this does not do what we want. What happens is for missing fields, use the default value from the constructor. But what we want is: for missing fields, to not change the value in the database.
We’ve created an annotation @RequestEntity to handle these parameters. Like @PathEntity, a URL template is tied to a domain entity, but now the request body is used to update the (detached) record. An example usage would be:

1 2 3 4 5

@RequestMapping(value = "/", method = RequestMethod.PUT) @ResponseBody public Invoice updateInvoice(@RequestEntity("invoiceId") Invoice invoice) {     // ... }

This controller method now only has to call the service method that updates the database. The code looks like this:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

package com.jay.demo; import java.lang.annotation.Documented; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** * Annotation to indicate a method parameter should be bound to the web request body. Used for {@link * org.springframework.web.bind.annotation.RequestMapping @RequestMapping} annotated methods. */ @Target(ElementType.PARAMETER) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface RequestEntity {     /**      * The name of the URL template that contains the .      *      * @return the name of the URL template that is the entity id      */     String value(); }

CRUD applications

The provided examples show the building blocks to reduce a CRUD application to almost no code beyond searching:

Create

The @RequestBody annotation combined with @Valid (see the first example) ensure that the controller only needs to save the record.

Read

The @PathEntity annotation in the second example already provides a loaded record, so the controller can simply return it. Only returning multiple records (i.e. searches) requires more code.

Update

The @RequestEntity annotation in the third example provides a detached, updated and optionally validated record. This includes partial updates The controller method only has to save it.

Delete

The @PathEntity annotation provides a record, so it can simply be removed.

As you can see, this means that implementing CRUD has become as trivial as calling your persistence layer. And as an added bonus, the more complex use cases are now also easier to implement: only the call to your business method is needed.

Conclusion

The examples in this article show that it is easy to extend the default Spring functionality to extract any information you want from the request. You can augment the existing functionality with, for example, JSR-303 validations. Or you can completely roll your own solution, including merging the request information with existing data. Combined with the generic Spring concept that any REST call is a method invocation, anything is possible. Your business needs are in control, not the technology.

Second example: PathEntityMethodArgumentResolver

 Another thing we encounter regularly, is that we want to issue a POST request to a URL to execute an action on a domain object. As we prefer not to repeat the code to retrieve the domain object, we’ve created an annotation @PathEntity so we can do this:

1 2 3 4 5

@RequestMapping(value = "/", method = RequestMethod.POST, params = "action=approve") @ResponseBody public Invoice approveInvoice(@PathEntity("invoiceId") Invoice invoice) {     // ... }

Granted, we could also do this by overriding the Spring ConversionService, but as we’ll see in the next example this approach has it’s advantages. The code for the @PathEntity annotation and the PathEntityMethodArgumentResolver to handle it is this:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

package com.jay.demo; import java.lang.annotation.Documented; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** * Annotation to indicate a method parameter should be bound to a URL template, and retrieved as a domain entity. * Used for  annotated methods. */ @Target(ElementType.PARAMETER) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface PathEntity {     /**      * The name of the URL template that contains the      * .      *      * @return the name of the URL template that is the entity id      */     String value(); }

And this is the class to resolve parameters annotated with @PathEntity:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114

package com.jay.demo; import java.util.Map; import javax.persistence.EntityManager; import javax.servlet.http.HttpServletRequest; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.core.MethodParameter; import org.springframework.core.convert.ConversionService; import org.springframework.web.bind.support.WebDataBinderFactory; import org.springframework.web.context.request.NativeWebRequest; import org.springframework.web.method.support.HandlerMethodArgumentResolver; import org.springframework.web.method.support.ModelAndViewContainer; import org.springframework.web.servlet.HandlerMapping; import nl.t42.generic.EntityNotFoundException; import nl.t42.generic.DomainEntity; /** * A  that converts a HTTP request body to a , provided that * the handler method argument is annotated with . */ public class PathEntityMethodArgumentResolver implements HandlerMethodArgumentResolver {     /**      * A conversion service to convert primary key values.      */     @Autowired     private ConversionService conversionService;     /**      * The entity manager used to retrieve the entities.      */     @Autowired     private EntityManager entityManager;     @Override     public boolean supportsParameter(MethodParameter parameter) {         return parameter.hasParameterAnnotation(PathEntity.class) && isADomainEntity(parameter);     }     /**      * Determine if a method parameter is a DomainEntity.      *      * @param parameter a method parameter      * @return  if the type of the parameter is (a subclass of) DomainEntity      */     protected boolean isADomainEntity(MethodParameter parameter) {         return DomainEntity.class.isAssignableFrom(parameter.getParameterType());     }     @Override     public DomainEntity resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,                                   NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {         String primaryKeyName = getPrimaryKeyName(parameter);         Long entityId = findPrimaryKeyValue(webRequest, primaryKeyName);         return findEntity(parameter, entityId);     }     /**      * Get the nam of the URL template that holds the primary key.      *      * @param parameter the method parameter      * @return the name of a URL template      */     protected String getPrimaryKeyName(MethodParameter parameter) {         return parameter.getParameterAnnotation(PathEntity.class).value();     }     private Long findPrimaryKeyValue(NativeWebRequest webRequest, String primaryKeyName) {         Map<String, String> pathVariables = getPathVariables(webRequest);         String primaryKeyValue = pathVariables.get(primaryKeyName);         if (primaryKeyValue == null) {             throw new IllegalStateException(String.format("The path variable %s cannot be resolved.", primaryKeyName));         }         return conversionService.convert(primaryKeyValue, Long.class);     }     private Map<String, String> getPathVariables(NativeWebRequest webRequest) {         HttpServletRequest httpServletRequest = webRequest.getNativeRequest(HttpServletRequest.class);         return (Map<String, String>) httpServletRequest.getAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE);     }     private DomainEntity findEntity(MethodParameter parameter, Long entityId) {         Class<? extends DomainEntity> entityType = (Class<? extends DomainEntity>) parameter.getParameterType();         DomainEntity entity = entityManager.find(entityType, entityId);         if (entity == null) {             throw new EntityNotFoundException(                     String.format("Cannot find a %s with id=%d", entityType.getSimpleName(), entityId));         }         return entity;     } }

Registering this MethodHandlerArgumentResolver is as usual:

1 2 3 4 5

<mvc:annotation-driven>         <mvc:argument-resolvers>             <bean class="nl.t42.spring31.PathEntityMethodArgumentResolver"/>         </mvc:argument-resolvers>     </mvc:annotation-driven>

With these two classes in place, we can identify our domain objects with our REST resources (URL’s). When the controller method is invoked, we have an instance of the domain entity the URL represents. Note that outside a transaction, this entity is a detached entity (this is prescribed by the JPA specification). So we still need to call EntityManager.merge(Object) to persist any changes.