Talk:AOP

We use aspectj for defining and using an aspect that serve an automatic objects caching service. It's not so hard, you can see our notes here: http://www.simexplorer.org/wiki/DevDoc/AspectJ

--NicolasDumoulin 13:00, 13 November 2009 (CET)

AspectJ supports annotations pretty well plus you still have all the old methods of defining a pointcut (or combination) if you need to really specific.

e.g.

@Around("@annotation(com.mycompany.BoundProp)")

would match all methods annotated with @com.mycompany.BoundProp

and you could still say only setters with 1 argument should be bound (since it might make sense to do that)

@Around("@annotation(com.mycompany.BoundProp) && execution(public * *..*.set*(*))")

--btilford 01:45, 19 November 2009 (CET)

I did a pretty bad job explaining how it works... ;)

So basically someone could create a library with an annotation and an "Aspect"

@Inherited
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface BoundProp {
    String value();
}

@Aspect
@Component
public class BoundPropertyAspect {
 
    private static final String SETTER = "^set";
    //execution(public * *(..))
    @Around(
"@annotation(test.BoundProp) && execution(public * *..*.set*(*))")
    private void propertyChanged(ProceedingJoinPoint joinPoint) {
        Logger.getLogger(getClass().getName()).info("Advice propertyChanged");
 
        SourceLocation source = joinPoint.getSourceLocation();
//        Logger.getLogger(getClass().getName()).info("\tSource: " + source.getFileName() + " (" + source.getLine() + ")");
 
        Object owner = joinPoint.getTarget();
        Logger.getLogger(getClass().getName()).info("\tOwner: " + owner.getClass().getName());
 
        Object newValue = joinPoint.getArgs()[0];
        Logger.getLogger(getClass().getName()).info("\tnewValue: " + newValue.toString());
 
 
        String setter = joinPoint.getSignature().getName();
        Logger.getLogger(getClass().getName()).info("\tmethodName: " + setter);
 
 
        PropertyChangeSupport pcs = null;
 
        Object old = null;
        try {
            old =
                    owner.getClass().getMethod(
                    setter.replaceFirst(SETTER, "get")).invoke(owner);
            pcs =
                    (PropertyChangeSupport) owner.getClass().getMethod(
                    "getPropertyChangeSupport").invoke(owner);
 
        } catch (Throwable ex) {
            Logger.getLogger(BoundPropertyAspect.class.getName()).log(
                    Level.SEVERE,
                    null, ex);
        } finally {
            try {
                joinPoint.proceed();
            } catch (Throwable ex) {
                Logger.getLogger(BoundPropertyAspect.class.getName()).log(
                        Level.SEVERE,
                        null, ex);
            }
        }
        if (pcs != null) {
            pcs.firePropertyChange(setter.replaceFirst(SETTER, ""), old,
                    newValue);
        }
 
 
    }
}

Then that aspect could be "triggered" by annotating a method with the @BoundProp annotation

class SomeClass {
    @BoundProp
    void setSomething(Object singleArg) {...}
    PropertyChangeSupport pcs = new PropertyChangeSupport()
    public PropertyChangeSupport getPropertyChangeSupport(){return pcs;}
}

--btilford 05:53, 20 November 2009 (CET)

I can totally aeaipcrpte the effort that Google is making to penetrate the social media sphere/crowdsourcing . There might be some traction with this latest attempt although the way it's being executed could be detrimental to the whole campaign. Just a couple of things.1: "+1" is hard to relate to. I noticed the Google has the Microsoft problem. They have brilliant engineers but they lack the coolness/connection factor. I think the coolness/connection factor is integral to the success of facebook and apple. When you use apple's and facebook's technology you feel like you connect with something deeper than the technology itself. There is a feeling associated with using the technology. For some reason it seems that Microsoft and Google don't put as much emphasis on design and how it "feels" to interact with their technology. I don't have much time so I'll get to the point I want to make. "+1" has no emotional appeal. Where in your life have you ever "+1ed"something. I like stuff all the time whether I do in internally or express it externally. +1 has no meaning outside of the Google context. So my first point has to do with what they named the technology. They could have come up with something that was already a part of the common lexicon and something a little richer . A synonym for like, Or something cool like sweet , hot , value , love . These might be a little corny but not as corny as +1 Secondly, I know they will be adding the +1 to pages on the web. They need to release that function right away. It should have been released for the pages before it was released for the SERPs. Right now it seems like Google is asking you to like how a SERP result looks. Because of how it's positioned it seems as though it's not asking how much you like the content on a page. For instance, to like something I'll have to run a query in Google. Visit the page. Rerun the query or hit the back button a couple of times and then hit the +1 button. That's a lot of work for a lazy guy like me and unfortunately I'm not getting paid by Google to do this work so instead of going back and +1ing a result I'll just continue onto my business. Great Idea. Poor Execution. Please Fix. I want you guys to stay around.

--Aneri 16:53, 21 October 2013 (CEST)

Okay, I am a huge google fan and I will not, under any cnecumstaicrs, notate how ironic it was that 40 people "liked this" in Google Reader. I will also, under no cnecumstaicrs, point out how strange +1d looks. Listen Google, this is another bomb waiting to happen, like Google Buzz and like Side Wiki; please don't do it, please come up with something that people really relate too, like "cool" or "recommend" or something else, just not +1.

--Yeye 11:33, 23 October 2013 (CEST)